diff --git a/lib/clif-backend/src/codegen.rs b/lib/clif-backend/src/codegen.rs
index 875302cae..f39a30408 100644
--- a/lib/clif-backend/src/codegen.rs
+++ b/lib/clif-backend/src/codegen.rs
@@ -29,7 +29,7 @@ use wasmer_runtime::{
         TableIndex as WasmerTableIndex, Type as WasmerType,
     },
     vm::{self, Ctx as WasmerVMContext},
-    LinearMemory,
+    memory::LinearMemory,
 };
 
 /// The converter namespace contains functions for converting a Cranelift module
diff --git a/lib/runtime/build/spectests.rs b/lib/runtime/build/spectests.rs
index 88f5db79e..e661fc707 100644
--- a/lib/runtime/build/spectests.rs
+++ b/lib/runtime/build/spectests.rs
@@ -268,7 +268,7 @@ fn test_module_{}() {{
         // self.module_calls.insert(self.last_module, vec![]);
         self.buffer.push_str(
             format!(
-                "fn create_module_{}() -> Box<Instance> {{
+                "fn create_module_{}() -> Instance {{
     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\");
@@ -583,7 +583,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/examples/simple/main.rs b/lib/runtime/examples/simple/main.rs
index 69be508a0..628025aa5 100644
--- a/lib/runtime/examples/simple/main.rs
+++ b/lib/runtime/examples/simple/main.rs
@@ -4,10 +4,10 @@ use wabt::wat2wasm;
 use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::{
     self as runtime,
-    export::{Context, Export},
+    export::{Context, Export, FuncPointer},
     import::Imports,
     types::{FuncSig, Type, Value},
-    vm, FuncRef,
+    vm,
 };
 
 static EXAMPLE_WASM: &'static [u8] = include_bytes!("simple.wasm");
@@ -20,7 +20,7 @@ fn main() -> Result<(), String> {
     env_namespace.insert(
         "print_i32",
         Export::Function {
-            func: unsafe { FuncRef::new(print_num as _) },
+            func: unsafe { FuncPointer::new(print_num as _) },
             ctx: Context::Internal,
             signature: FuncSig {
                 params: vec![Type::I32],
diff --git a/lib/runtime/examples/test.rs b/lib/runtime/examples/test.rs
index 1c3dca0bd..ce3892e34 100644
--- a/lib/runtime/examples/test.rs
+++ b/lib/runtime/examples/test.rs
@@ -21,7 +21,7 @@ fn generate_imports() -> Rc<Imports> {
     Rc::new(imports)
 }
 
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i64)))
       (func (;0;) (type 0) (result i64)
diff --git a/lib/runtime/src/backing.rs b/lib/runtime/src/backing.rs
index 5588c5731..f3a813798 100644
--- a/lib/runtime/src/backing.rs
+++ b/lib/runtime/src/backing.rs
@@ -205,7 +205,7 @@ fn import_memories(
             }) => {
                 if expected_memory_desc.fits_in_imported(&memory_desc) {
                     memories.push(vm::ImportedMemory {
-                        memory: local,
+                        memory: local.inner(),
                         vmctx: match ctx {
                             Context::External(ctx) => ctx,
                             Context::Internal => vmctx,
@@ -284,7 +284,7 @@ fn import_globals(
         match import {
             Some(Export::Global { local, global }) => {
                 if &global == global_desc {
-                    globals.push(vm::ImportedGlobal { global: local });
+                    globals.push(vm::ImportedGlobal { global: local.inner() });
                 } else {
                     return Err(format!(
                         "unexpected global description for {:?}:{:?}",
diff --git a/lib/runtime/src/export.rs b/lib/runtime/src/export.rs
index f9af52eea..276bd3dd4 100644
--- a/lib/runtime/src/export.rs
+++ b/lib/runtime/src/export.rs
@@ -1,8 +1,10 @@
 use crate::{
-    instance::FuncRef,
     types::{FuncSig, GlobalDesc, Memory, Table},
+    module::ExportIndex,
     vm,
+    Instance,
 };
+use hashbrown::hash_map;
 
 #[derive(Debug, Copy, Clone)]
 pub enum Context {
@@ -13,22 +15,111 @@ pub enum Context {
 #[derive(Debug, Clone)]
 pub enum Export {
     Function {
-        func: FuncRef,
+        func: FuncPointer,
         ctx: Context,
         signature: FuncSig,
     },
     Memory {
-        local: *mut vm::LocalMemory,
+        local: MemoryPointer,
         ctx: Context,
         memory: Memory,
     },
     Table {
-        local: *mut vm::LocalTable,
+        local: TablePointer,
         ctx: Context,
         table: Table,
     },
     Global {
-        local: *mut vm::LocalGlobal,
+        local: GlobalPointer,
         global: GlobalDesc,
     },
 }
+
+#[derive(Debug, Clone)]
+pub struct FuncPointer(*const vm::Func);
+
+impl FuncPointer {
+    /// This needs to be unsafe because there is
+    /// no way to check whether the passed function
+    /// is valid and has the right signature.
+    pub unsafe fn new(f: *const vm::Func) -> Self {
+        FuncPointer(f)
+    }
+
+    pub(crate) fn inner(&self) -> *const vm::Func {
+        self.0
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct MemoryPointer(*mut vm::LocalMemory);
+
+impl MemoryPointer {
+    /// This needs to be unsafe because there is
+    /// no way to check whether the passed function
+    /// is valid and has the right signature.
+    pub unsafe fn new(f: *mut vm::LocalMemory) -> Self {
+        MemoryPointer(f)
+    }
+
+    pub(crate) fn inner(&self) -> *mut vm::LocalMemory {
+        self.0
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TablePointer(*mut vm::LocalTable);
+
+impl TablePointer {
+    /// This needs to be unsafe because there is
+    /// no way to check whether the passed function
+    /// is valid and has the right signature.
+    pub unsafe fn new(f: *mut vm::LocalTable) -> Self {
+        TablePointer(f)
+    }
+
+    pub(crate) fn inner(&self) -> *mut vm::LocalTable {
+        self.0
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct GlobalPointer(*mut vm::LocalGlobal);
+
+impl GlobalPointer {
+    /// This needs to be unsafe because there is
+    /// no way to check whether the passed function
+    /// is valid and has the right signature.
+    pub unsafe fn new(f: *mut vm::LocalGlobal) -> Self {
+        GlobalPointer(f)
+    }
+
+    pub(crate) fn inner(&self) -> *mut vm::LocalGlobal {
+        self.0
+    }
+}
+
+pub struct ExportIter<'a> {
+    instance: &'a Instance,
+    iter: hash_map::Iter<'a, String, ExportIndex>,
+}
+
+impl<'a> ExportIter<'a> {
+    pub(crate) fn new(instance: &'a Instance) -> Self {
+        Self {
+            instance,
+            iter: instance.module.exports.iter(),
+        }
+    }
+}
+
+impl<'a> Iterator for ExportIter<'a> {
+    type Item = (String, Export);
+    fn next(&mut self) -> Option<(String, Export)> {
+        let (name, export_index) = self.iter.next()?;
+        Some((
+            name.clone(),
+            self.instance.get_export_from_index(export_index),
+        ))
+    }
+}
\ No newline at end of file
diff --git a/lib/runtime/src/instance.rs b/lib/runtime/src/instance.rs
index 74116cb4a..71de0a1a1 100644
--- a/lib/runtime/src/instance.rs
+++ b/lib/runtime/src/instance.rs
@@ -1,19 +1,17 @@
 use crate::recovery::call_protected;
 use crate::{
     backing::{ImportBacking, LocalBacking},
-    export::{Context, Export},
+    export::{Context, Export, ExportIter, FuncPointer, MemoryPointer},
     import::{ImportResolver, Namespace},
     module::{ExportIndex, Module},
     types::{FuncIndex, FuncSig, MapIndex, Memory, MemoryIndex, Type, Value},
     vm,
 };
-use hashbrown::hash_map;
 use libffi::high::{arg as libffi_arg, call as libffi_call, CodePtr};
 use std::rc::Rc;
 use std::{iter, mem};
 
-pub struct Instance {
-    pub module: Module,
+struct InstanceInner {
     #[allow(dead_code)]
     pub(crate) backing: LocalBacking,
     #[allow(dead_code)]
@@ -22,11 +20,16 @@ pub struct Instance {
     vmctx: Box<vm::Ctx>,
 }
 
+pub struct Instance {
+    pub module: Module,
+    inner: Box<InstanceInner>,
+}
+
 impl Instance {
     pub(crate) fn new(
         module: Module,
         imports: Rc<dyn ImportResolver>,
-    ) -> Result<Box<Instance>, String> {
+    ) -> Result<Instance, String> {
         // We need the backing and import_backing to create a vm::Ctx, but we need
         // a vm::Ctx to create a backing and an import_backing. The solution is to create an
         // uninitialized vm::Ctx and then initialize it in-place.
@@ -36,8 +39,7 @@ impl Instance {
         let backing = LocalBacking::new(&module, &import_backing, &mut *vmctx);
 
         // When Pin is stablized, this will use `Box::pinned` instead of `Box::new`.
-        let mut instance = Box::new(Instance {
-            module,
+        let mut inner = Box::new(InstanceInner {
             backing,
             imports,
             import_backing,
@@ -46,7 +48,12 @@ impl Instance {
 
         // Initialize the vm::Ctx in-place after the import_backing
         // has been boxed.
-        *instance.vmctx = vm::Ctx::new(&mut instance.backing, &mut instance.import_backing);
+        *inner.vmctx = vm::Ctx::new(&mut inner.backing, &mut inner.import_backing);
+
+        let mut instance = Instance {
+            module,
+            inner,
+        };
 
         if let Some(start_index) = instance.module.start_func {
             instance.call_with_index(start_index, &[])?;
@@ -77,6 +84,12 @@ impl Instance {
         self.call_with_index(func_index, args)
     }
 
+    pub fn exports(&self) -> ExportIter {
+        ExportIter::new(self)
+    }
+}
+
+impl Instance {
     fn call_with_index(
         &mut self,
         func_index: FuncIndex,
@@ -87,7 +100,7 @@ impl Instance {
         let func_ptr = CodePtr::from_ptr(func_ref.inner() as _);
         let vmctx_ptr = match ctx {
             Context::External(vmctx) => vmctx,
-            Context::Internal => &mut *self.vmctx,
+            Context::Internal => &mut *self.inner.vmctx,
         };
 
         assert!(
@@ -130,11 +143,7 @@ impl Instance {
         })
     }
 
-    pub fn exports(&self) -> ExportIter {
-        ExportIter::new(self)
-    }
-
-    fn get_export_from_index(&self, export_index: &ExportIndex) -> Export {
+    pub(crate) fn get_export_from_index(&self, export_index: &ExportIndex) -> Export {
         match export_index {
             ExportIndex::Func(func_index) => {
                 let (func, ctx, signature) = self.get_func_from_index(*func_index);
@@ -143,7 +152,7 @@ impl Instance {
                     func,
                     ctx: match ctx {
                         Context::Internal => {
-                            Context::External(&*self.vmctx as *const vm::Ctx as *mut vm::Ctx)
+                            Context::External(&*self.inner.vmctx as *const vm::Ctx as *mut vm::Ctx)
                         }
                         ctx @ Context::External(_) => ctx,
                     },
@@ -156,7 +165,7 @@ impl Instance {
                     local,
                     ctx: match ctx {
                         Context::Internal => {
-                            Context::External(&*self.vmctx as *const vm::Ctx as *mut vm::Ctx)
+                            Context::External(&*self.inner.vmctx as *const vm::Ctx as *mut vm::Ctx)
                         }
                         ctx @ Context::External(_) => ctx,
                     },
@@ -168,7 +177,7 @@ impl Instance {
         }
     }
 
-    fn get_func_from_index(&self, func_index: FuncIndex) -> (FuncRef, Context, FuncSig) {
+    fn get_func_from_index(&self, func_index: FuncIndex) -> (FuncPointer, Context, FuncSig) {
         let sig_index = *self
             .module
             .func_assoc
@@ -176,7 +185,7 @@ impl Instance {
             .expect("broken invariant, incorrect func index");
 
         let (func_ptr, ctx) = if self.module.is_imported_function(func_index) {
-            let imported_func = &self.import_backing.functions[func_index.index()];
+            let imported_func = &self.inner.import_backing.functions[func_index.index()];
             (
                 imported_func.func as *const _,
                 Context::External(imported_func.vmctx),
@@ -195,13 +204,13 @@ impl Instance {
 
         let signature = self.module.sig_registry.lookup_func_sig(sig_index).clone();
 
-        (FuncRef(func_ptr), ctx, signature)
+        (unsafe { FuncPointer::new(func_ptr) }, ctx, signature)
     }
 
     fn get_memory_from_index(
         &self,
         mem_index: MemoryIndex,
-    ) -> (*mut vm::LocalMemory, Context, Memory) {
+    ) -> (MemoryPointer, Context, Memory) {
         if self.module.is_imported_memory(mem_index) {
             let &(_, mem) = &self
                 .module
@@ -209,14 +218,12 @@ impl Instance {
                 .get(mem_index)
                 .expect("missing imported memory index");
             let vm::ImportedMemory { memory, vmctx } =
-                &self.import_backing.memories[mem_index.index()];
-            (*memory, Context::External(*vmctx), *mem)
+                &self.inner.import_backing.memories[mem_index.index()];
+            (unsafe { MemoryPointer::new(*memory) }, Context::External(*vmctx), *mem)
         } else {
-            //           let vm_mem = .memories[mem_index.index() as usize];
-            let vm_mem =
-                unsafe { &mut (*self.vmctx.local_backing).memories[mem_index.index() as usize] };
+            let vm_mem = &self.inner.backing.memories[mem_index.index() as usize];
             (
-                &mut vm_mem.into_vm_memory(),
+                unsafe { MemoryPointer::new(&mut vm_mem.into_vm_memory()) },
                 Context::Internal,
                 *self
                     .module
@@ -228,7 +235,7 @@ impl Instance {
     }
 }
 
-impl Namespace for Box<Instance> {
+impl Namespace for Instance {
     fn get_export(&self, name: &str) -> Option<Export> {
         let export_index = self.module.exports.get(name)?;
 
@@ -236,47 +243,6 @@ impl Namespace for Box<Instance> {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct FuncRef(*const vm::Func);
-
-impl FuncRef {
-    /// This needs to be unsafe because there is
-    /// no way to check whether the passed function
-    /// is valid and has the right signature.
-    pub unsafe fn new(f: *const vm::Func) -> Self {
-        FuncRef(f)
-    }
-
-    pub(crate) fn inner(&self) -> *const vm::Func {
-        self.0
-    }
-}
-
-pub struct ExportIter<'a> {
-    instance: &'a Instance,
-    iter: hash_map::Iter<'a, String, ExportIndex>,
-}
-
-impl<'a> ExportIter<'a> {
-    fn new(instance: &'a Instance) -> Self {
-        Self {
-            instance,
-            iter: instance.module.exports.iter(),
-        }
-    }
-}
-
-impl<'a> Iterator for ExportIter<'a> {
-    type Item = (String, Export);
-    fn next(&mut self) -> Option<(String, Export)> {
-        let (name, export_index) = self.iter.next()?;
-        Some((
-            name.clone(),
-            self.instance.get_export_from_index(export_index),
-        ))
-    }
-}
-
 // TODO Remove this later, only needed for compilation till emscripten is updated
 impl Instance {
     pub fn memory_offset_addr(&self, _index: usize, _offset: usize) -> *const usize {
diff --git a/lib/runtime/src/lib.rs b/lib/runtime/src/lib.rs
index 4f8be99e7..f7e78ac33 100644
--- a/lib/runtime/src/lib.rs
+++ b/lib/runtime/src/lib.rs
@@ -4,24 +4,23 @@ extern crate field_offset;
 
 #[macro_use]
 mod macros;
-pub mod backend;
 mod backing;
-pub mod export;
-pub mod import;
 mod instance;
-mod memory;
 mod mmap;
-pub mod module;
 mod recovery;
 mod sig_registry;
 mod sighandler;
+pub mod backend;
+pub mod export;
+pub mod import;
+pub mod module;
+pub mod memory;
 pub mod table;
 pub mod types;
 pub mod vm;
 pub mod vmcalls;
 
-pub use self::instance::{FuncRef, Instance};
-pub use self::memory::LinearMemory;
+pub use self::instance::Instance;
 
 /// Compile a webassembly module using the provided compiler.
 pub fn compile(wasm: &[u8], compiler: &dyn backend::Compiler) -> Result<module::Module, String> {
diff --git a/lib/runtime/src/macros.rs b/lib/runtime/src/macros.rs
index c27b1e8e0..fe2bd1a7f 100644
--- a/lib/runtime/src/macros.rs
+++ b/lib/runtime/src/macros.rs
@@ -1,4 +1,3 @@
-#[macro_export]
 macro_rules! debug {
     ($fmt:expr) => (if cfg!(any(debug_assertions, feature="debug")) { println!(concat!("wasmer-runtime(:{})::", $fmt), line!()) });
     ($fmt:expr, $($arg:tt)*) => (if cfg!(any(debug_assertions, feature="debug")) { println!(concat!("wasmer-runtime(:{})::", $fmt, "\n"), line!(), $($arg)*) });
diff --git a/lib/runtime/src/memory.rs b/lib/runtime/src/memory.rs
index ed0a309b4..638a0be8e 100644
--- a/lib/runtime/src/memory.rs
+++ b/lib/runtime/src/memory.rs
@@ -8,7 +8,7 @@ use std::ops::{Deref, DerefMut};
 use crate::{
     mmap::{Mmap, Protect},
     types::Memory,
-    vm::LocalMemory,
+    vm,
 };
 
 /// A linear memory instance.
@@ -38,16 +38,16 @@ pub struct LinearMemory {
 
 /// It holds the raw bytes of memory accessed by a WebAssembly Instance
 impl LinearMemory {
-    pub const PAGE_SIZE: u32 = 65_536;
-    pub const MAX_PAGES: u32 = 65_536;
+    pub(crate) const PAGE_SIZE: u32 = 65_536;
+    pub(crate) const MAX_PAGES: u32 = 65_536;
     pub const DEFAULT_HEAP_SIZE: usize = 1 << 32; // 4 GiB
     pub const DEFAULT_GUARD_SIZE: usize = 1 << 31; // 2 GiB
-    pub const DEFAULT_SIZE: usize = Self::DEFAULT_HEAP_SIZE + Self::DEFAULT_GUARD_SIZE; // 6 GiB
+    pub(crate) const DEFAULT_SIZE: usize = Self::DEFAULT_HEAP_SIZE + Self::DEFAULT_GUARD_SIZE; // 6 GiB
 
     /// Create a new linear memory instance with specified initial and maximum number of pages.
     ///
     /// `maximum` cannot be set to more than `65536` pages.
-    pub fn new(mem: &Memory) -> Self {
+    pub(crate) fn new(mem: &Memory) -> Self {
         assert!(mem.min <= Self::MAX_PAGES);
         assert!(mem.max.is_none() || mem.max.unwrap() <= Self::MAX_PAGES);
         debug!("Instantiate LinearMemory(mem: {:?})", mem);
@@ -92,7 +92,7 @@ impl LinearMemory {
     }
 
     /// Returns an base address of this linear memory.
-    fn base(&mut self) -> *mut u8 {
+    fn base(&self) -> *mut u8 {
         self.mmap.as_ptr()
     }
 
@@ -110,8 +110,8 @@ impl LinearMemory {
         self.max.unwrap_or(Self::MAX_PAGES)
     }
 
-    pub(crate) fn into_vm_memory(&mut self) -> LocalMemory {
-        LocalMemory {
+    pub(crate) fn into_vm_memory(&self) -> vm::LocalMemory {
+        vm::LocalMemory {
             base: self.base(),
             size: self.size(),
         }
diff --git a/lib/runtime/src/module.rs b/lib/runtime/src/module.rs
index cc668514f..ce2f41d01 100644
--- a/lib/runtime/src/module.rs
+++ b/lib/runtime/src/module.rs
@@ -43,7 +43,7 @@ impl Module {
     }
 
     /// Instantiate a webassembly module with the provided imports.
-    pub fn instantiate(&self, imports: Rc<dyn ImportResolver>) -> Result<Box<Instance>, String> {
+    pub fn instantiate(&self, imports: Rc<dyn ImportResolver>) -> Result<Instance, String> {
         Instance::new(Module(Rc::clone(&self.0)), imports)
     }
 }
diff --git a/lib/runtime/tests/spectests/address.rs b/lib/runtime/tests/spectests/address.rs
index 7a652c6b3..833dac8e8 100644
--- a/lib/runtime/tests/spectests/address.rs
+++ b/lib/runtime/tests/spectests/address.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i32)))
@@ -148,11 +152,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -756,14 +757,14 @@ fn c74_l191_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c75_l192_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -771,14 +772,14 @@ fn c75_l192_assert_trap() {
 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);
+    let result = c76_l194_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -786,14 +787,14 @@ fn c76_l194_assert_trap() {
 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);
+    let result = c77_l195_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -801,14 +802,14 @@ fn c77_l195_assert_trap() {
 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);
+    let result = c78_l196_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -816,14 +817,14 @@ fn c78_l196_assert_trap() {
 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);
+    let result = c79_l197_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -831,14 +832,14 @@ fn c79_l197_assert_trap() {
 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);
+    let result = c80_l198_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -846,14 +847,14 @@ fn c80_l198_assert_trap() {
 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);
+    let result = c81_l200_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -861,14 +862,14 @@ fn c81_l200_assert_trap() {
 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);
+    let result = c82_l201_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -876,14 +877,14 @@ fn c82_l201_assert_trap() {
 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);
+    let result = c83_l202_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -891,14 +892,14 @@ fn c83_l202_assert_trap() {
 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);
+    let result = c84_l203_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -906,31 +907,23 @@ fn c84_l203_assert_trap() {
 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);
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 216
@@ -1015,7 +1008,7 @@ fn test_module_1() {
     c73_l190_action_invoke(&mut instance);
     c74_l191_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i64)))
       (type (;1;) (func (param i32)))
@@ -1198,11 +1191,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -2046,14 +2036,14 @@ fn c191_l478_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c192_l479_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2061,14 +2051,14 @@ fn c192_l479_assert_trap() {
 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);
+    let result = c193_l481_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2076,14 +2066,14 @@ fn c193_l481_assert_trap() {
 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);
+    let result = c194_l482_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2091,14 +2081,14 @@ fn c194_l482_assert_trap() {
 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);
+    let result = c195_l483_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2106,14 +2096,14 @@ fn c195_l483_assert_trap() {
 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);
+    let result = c196_l484_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2121,14 +2111,14 @@ fn c196_l484_assert_trap() {
 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);
+    let result = c197_l485_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2136,14 +2126,14 @@ fn c197_l485_assert_trap() {
 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);
+    let result = c198_l486_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2151,14 +2141,14 @@ fn c198_l486_assert_trap() {
 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);
+    let result = c199_l487_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2166,14 +2156,14 @@ fn c199_l487_assert_trap() {
 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);
+    let result = c200_l489_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2181,14 +2171,14 @@ fn c200_l489_assert_trap() {
 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);
+    let result = c201_l490_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2196,14 +2186,14 @@ fn c201_l490_assert_trap() {
 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);
+    let result = c202_l491_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2211,14 +2201,14 @@ fn c202_l491_assert_trap() {
 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);
+    let result = c203_l492_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2226,14 +2216,14 @@ fn c203_l492_assert_trap() {
 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);
+    let result = c204_l493_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2241,14 +2231,14 @@ fn c204_l493_assert_trap() {
 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);
+    let result = c205_l494_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2256,14 +2246,14 @@ fn c205_l494_assert_trap() {
 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);
+    let result = c206_l495_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2379,7 +2369,7 @@ fn test_module_2() {
     c190_l477_action_invoke(&mut instance);
     c191_l478_action_invoke(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result f32)))
       (type (;1;) (func (param i32)))
@@ -2412,11 +2402,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -2461,15 +2448,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -2549,14 +2533,14 @@ fn c221_l538_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c222_l539_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2564,14 +2548,14 @@ fn c222_l539_assert_trap() {
 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);
+    let result = c223_l541_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2579,14 +2563,14 @@ fn c223_l541_assert_trap() {
 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);
+    let result = c224_l542_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2612,7 +2596,7 @@ fn test_module_3() {
     c220_l537_action_invoke(&mut instance);
     c221_l538_action_invoke(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result f64)))
       (type (;1;) (func (param i32)))
@@ -2645,11 +2629,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -2694,15 +2675,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -2782,14 +2760,14 @@ fn c239_l585_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c240_l586_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2797,14 +2775,14 @@ fn c240_l586_assert_trap() {
 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);
+    let result = c241_l588_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2812,14 +2790,14 @@ fn c241_l588_assert_trap() {
 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);
+    let result = c242_l589_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
diff --git a/lib/runtime/tests/spectests/align.rs b/lib/runtime/tests/spectests/align.rs
index 4cfc63733..8031b59fe 100644
--- a/lib/runtime/tests/spectests/align.rs
+++ b/lib/runtime/tests/spectests/align.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -25,11 +29,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -45,7 +46,7 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -55,11 +56,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -75,7 +73,7 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -85,11 +83,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -105,7 +100,7 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -115,11 +110,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -135,7 +127,7 @@ fn test_module_4() {
     // We group the calls together
     start_module_4(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -145,11 +137,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -165,7 +154,7 @@ fn test_module_5() {
     // We group the calls together
     start_module_5(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -175,11 +164,8 @@ fn create_module_6() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -195,7 +181,7 @@ fn test_module_6() {
     // We group the calls together
     start_module_6(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -205,11 +191,8 @@ fn create_module_7() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -225,7 +208,7 @@ fn test_module_7() {
     // We group the calls together
     start_module_7(&mut instance);
 }
-fn create_module_8() -> Box<Instance> {
+fn create_module_8() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -235,11 +218,8 @@ fn create_module_8() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_8(instance: &mut Instance) {
@@ -255,7 +235,7 @@ fn test_module_8() {
     // We group the calls together
     start_module_8(&mut instance);
 }
-fn create_module_9() -> Box<Instance> {
+fn create_module_9() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -265,11 +245,8 @@ fn create_module_9() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_9(instance: &mut Instance) {
@@ -285,7 +262,7 @@ fn test_module_9() {
     // We group the calls together
     start_module_9(&mut instance);
 }
-fn create_module_10() -> Box<Instance> {
+fn create_module_10() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -295,11 +272,8 @@ fn create_module_10() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_10(instance: &mut Instance) {
@@ -315,7 +289,7 @@ fn test_module_10() {
     // We group the calls together
     start_module_10(&mut instance);
 }
-fn create_module_11() -> Box<Instance> {
+fn create_module_11() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -325,11 +299,8 @@ fn create_module_11() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_11(instance: &mut Instance) {
@@ -345,7 +316,7 @@ fn test_module_11() {
     // We group the calls together
     start_module_11(&mut instance);
 }
-fn create_module_12() -> Box<Instance> {
+fn create_module_12() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -355,11 +326,8 @@ fn create_module_12() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_12(instance: &mut Instance) {
@@ -375,7 +343,7 @@ fn test_module_12() {
     // We group the calls together
     start_module_12(&mut instance);
 }
-fn create_module_13() -> Box<Instance> {
+fn create_module_13() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -385,11 +353,8 @@ fn create_module_13() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_13(instance: &mut Instance) {
@@ -405,7 +370,7 @@ fn test_module_13() {
     // We group the calls together
     start_module_13(&mut instance);
 }
-fn create_module_14() -> Box<Instance> {
+fn create_module_14() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -415,11 +380,8 @@ fn create_module_14() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_14(instance: &mut Instance) {
@@ -435,7 +397,7 @@ fn test_module_14() {
     // We group the calls together
     start_module_14(&mut instance);
 }
-fn create_module_15() -> Box<Instance> {
+fn create_module_15() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -445,11 +407,8 @@ fn create_module_15() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_15(instance: &mut Instance) {
@@ -465,7 +424,7 @@ fn test_module_15() {
     // We group the calls together
     start_module_15(&mut instance);
 }
-fn create_module_16() -> Box<Instance> {
+fn create_module_16() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -475,11 +434,8 @@ fn create_module_16() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_16(instance: &mut Instance) {
@@ -495,7 +451,7 @@ fn test_module_16() {
     // We group the calls together
     start_module_16(&mut instance);
 }
-fn create_module_17() -> Box<Instance> {
+fn create_module_17() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -505,11 +461,8 @@ fn create_module_17() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_17(instance: &mut Instance) {
@@ -525,7 +478,7 @@ fn test_module_17() {
     // We group the calls together
     start_module_17(&mut instance);
 }
-fn create_module_18() -> Box<Instance> {
+fn create_module_18() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -535,11 +488,8 @@ fn create_module_18() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_18(instance: &mut Instance) {
@@ -555,7 +505,7 @@ fn test_module_18() {
     // We group the calls together
     start_module_18(&mut instance);
 }
-fn create_module_19() -> Box<Instance> {
+fn create_module_19() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -565,11 +515,8 @@ fn create_module_19() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_19(instance: &mut Instance) {
@@ -585,7 +532,7 @@ fn test_module_19() {
     // We group the calls together
     start_module_19(&mut instance);
 }
-fn create_module_20() -> Box<Instance> {
+fn create_module_20() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -595,11 +542,8 @@ fn create_module_20() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_20(instance: &mut Instance) {
@@ -615,7 +559,7 @@ fn test_module_20() {
     // We group the calls together
     start_module_20(&mut instance);
 }
-fn create_module_21() -> Box<Instance> {
+fn create_module_21() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -625,11 +569,8 @@ fn create_module_21() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_21(instance: &mut Instance) {
@@ -645,7 +586,7 @@ fn test_module_21() {
     // We group the calls together
     start_module_21(&mut instance);
 }
-fn create_module_22() -> Box<Instance> {
+fn create_module_22() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -655,11 +596,8 @@ fn create_module_22() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_22(instance: &mut Instance) {
@@ -675,7 +613,7 @@ fn test_module_22() {
     // We group the calls together
     start_module_22(&mut instance);
 }
-fn create_module_23() -> Box<Instance> {
+fn create_module_23() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -685,11 +623,8 @@ fn create_module_23() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_23(instance: &mut Instance) {
@@ -700,746 +635,375 @@ fn start_module_23(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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");
 }
@@ -1447,10 +1011,7 @@ fn c69_l306_assert_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 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");
 }
@@ -1458,10 +1019,7 @@ fn c70_l310_assert_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 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");
 }
@@ -1469,10 +1027,7 @@ fn c71_l314_assert_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 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");
 }
@@ -1480,10 +1035,7 @@ fn c72_l318_assert_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 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");
 }
@@ -1491,10 +1043,7 @@ fn c73_l322_assert_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 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");
 }
@@ -1502,10 +1051,7 @@ fn c74_l326_assert_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 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");
 }
@@ -1513,10 +1059,7 @@ fn c75_l330_assert_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 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");
 }
@@ -1524,10 +1067,7 @@ fn c76_l334_assert_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 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");
 }
@@ -1535,10 +1075,7 @@ fn c77_l338_assert_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 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");
 }
@@ -1546,10 +1083,7 @@ fn c78_l342_assert_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 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");
 }
@@ -1557,10 +1091,7 @@ fn c79_l346_assert_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 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");
 }
@@ -1568,10 +1099,7 @@ fn c80_l350_assert_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 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");
 }
@@ -1579,10 +1107,7 @@ fn c81_l354_assert_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 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");
 }
@@ -1590,10 +1115,7 @@ fn c82_l358_assert_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 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");
 }
@@ -1601,10 +1123,7 @@ fn c83_l363_assert_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 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");
 }
@@ -1612,10 +1131,7 @@ fn c84_l367_assert_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 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");
 }
@@ -1623,10 +1139,7 @@ fn c85_l371_assert_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 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");
 }
@@ -1634,10 +1147,7 @@ fn c86_l375_assert_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 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");
 }
@@ -1645,10 +1155,7 @@ fn c87_l379_assert_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 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");
 }
@@ -1656,10 +1163,7 @@ fn c88_l383_assert_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 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");
 }
@@ -1667,10 +1171,7 @@ fn c89_l387_assert_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 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");
 }
@@ -1678,10 +1179,7 @@ fn c90_l391_assert_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 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");
 }
@@ -1689,10 +1187,7 @@ fn c91_l395_assert_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 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");
 }
@@ -1700,10 +1195,7 @@ fn c92_l399_assert_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 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");
 }
@@ -1711,10 +1203,7 @@ fn c93_l403_assert_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 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");
 }
@@ -1722,10 +1211,7 @@ fn c94_l407_assert_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 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");
 }
@@ -1733,10 +1219,7 @@ fn c95_l411_assert_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 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");
 }
@@ -1744,10 +1227,7 @@ fn c96_l415_assert_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 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");
 }
@@ -1755,10 +1235,7 @@ fn c97_l420_assert_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 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");
 }
@@ -1766,10 +1243,7 @@ fn c98_l424_assert_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 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");
 }
@@ -1777,10 +1251,7 @@ fn c99_l428_assert_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 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");
 }
@@ -1788,10 +1259,7 @@ fn c100_l432_assert_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 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");
 }
@@ -1799,10 +1267,7 @@ fn c101_l436_assert_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 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");
 }
@@ -1810,10 +1275,7 @@ fn c102_l440_assert_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 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");
 }
@@ -1821,10 +1283,7 @@ fn c103_l444_assert_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 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");
 }
@@ -1832,10 +1291,7 @@ fn c104_l448_assert_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 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");
 }
@@ -1848,7 +1304,7 @@ fn test_module_23() {
     // We group the calls together
     start_module_23(&mut instance);
 }
-fn create_module_24() -> Box<Instance> {
+fn create_module_24() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result f32)))
       (type (;1;) (func (param i32) (result f64)))
@@ -2417,11 +1873,8 @@ fn create_module_24() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_24(instance: &mut Instance) {
@@ -2504,10 +1957,7 @@ fn c115_l811_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2515,10 +1965,7 @@ fn c116_l813_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2526,10 +1973,7 @@ fn c117_l814_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2537,10 +1981,7 @@ fn c118_l815_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2548,10 +1989,7 @@ fn c119_l816_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2559,10 +1997,7 @@ fn c120_l817_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2570,10 +2005,7 @@ fn c121_l818_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2581,10 +2013,7 @@ fn c122_l819_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2592,10 +2021,7 @@ fn c123_l820_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2603,10 +2029,7 @@ fn c124_l821_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2614,10 +2037,7 @@ fn c125_l822_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2625,10 +2045,7 @@ fn c126_l823_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2636,10 +2053,7 @@ fn c127_l824_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2647,10 +2061,7 @@ fn c128_l825_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2658,10 +2069,7 @@ fn c129_l826_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2669,10 +2077,7 @@ fn c130_l828_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2680,10 +2085,7 @@ fn c131_l829_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2691,10 +2093,7 @@ fn c132_l830_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2702,10 +2101,7 @@ fn c133_l831_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2713,10 +2109,7 @@ fn c134_l832_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2724,10 +2117,7 @@ fn c135_l833_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2735,10 +2125,7 @@ fn c136_l834_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2746,10 +2133,7 @@ fn c137_l835_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2757,10 +2141,7 @@ fn c138_l836_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2768,10 +2149,7 @@ fn c139_l837_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2779,10 +2157,7 @@ fn c140_l838_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2790,10 +2165,7 @@ fn c141_l839_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2801,10 +2173,7 @@ fn c142_l840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2812,10 +2181,7 @@ fn c143_l841_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2823,10 +2189,7 @@ fn c144_l842_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2834,10 +2197,7 @@ fn c145_l843_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2845,10 +2205,7 @@ fn c146_l844_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2856,10 +2213,7 @@ fn c147_l845_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2867,10 +2221,7 @@ fn c148_l846_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2878,10 +2229,7 @@ fn c149_l847_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2889,10 +2237,7 @@ fn c150_l848_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2900,10 +2245,7 @@ fn c151_l849_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
diff --git a/lib/runtime/tests/spectests/binary.rs b/lib/runtime/tests/spectests/binary.rs
index e39d6cedd..47e42d2d9 100644
--- a/lib/runtime/tests/spectests/binary.rs
+++ b/lib/runtime/tests/spectests/binary.rs
@@ -5,25 +5,26 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -39,15 +40,12 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -63,15 +61,12 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -87,15 +82,12 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -108,10 +100,7 @@ fn start_module_4(instance: &mut Instance) {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 7
@@ -119,10 +108,7 @@ fn c4_l6_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 8
@@ -130,10 +116,7 @@ fn c5_l7_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 9
@@ -141,10 +124,7 @@ fn c6_l8_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 10
@@ -152,10 +132,7 @@ fn c7_l9_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 11
@@ -163,10 +140,7 @@ fn c8_l10_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 12
@@ -174,10 +148,7 @@ fn c9_l11_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 13
@@ -185,10 +156,7 @@ fn c10_l12_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 14
@@ -196,10 +164,7 @@ fn c11_l13_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 15
@@ -207,10 +172,7 @@ fn c12_l14_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 16
@@ -218,10 +180,7 @@ fn c13_l15_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 17
@@ -229,10 +188,7 @@ fn c14_l16_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 18
@@ -240,10 +196,7 @@ fn c15_l17_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 21
@@ -251,10 +204,7 @@ fn c16_l18_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 24
@@ -262,10 +212,7 @@ fn c17_l21_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 25
@@ -273,10 +220,7 @@ fn c18_l24_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 28
@@ -284,10 +228,7 @@ fn c19_l25_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 31
@@ -295,10 +236,7 @@ fn c20_l28_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 34
@@ -306,10 +244,7 @@ fn c21_l31_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 36
@@ -317,10 +252,7 @@ fn c22_l34_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 37
@@ -328,10 +260,7 @@ fn c23_l36_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 38
@@ -339,10 +268,7 @@ fn c24_l37_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 39
@@ -350,10 +276,7 @@ fn c25_l38_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 40
@@ -361,10 +284,7 @@ fn c26_l39_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 41
@@ -372,10 +292,7 @@ fn c27_l40_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 42
@@ -383,10 +300,7 @@ fn c28_l41_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 43
@@ -394,10 +308,7 @@ fn c29_l42_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 44
@@ -405,10 +316,7 @@ fn c30_l43_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 47
@@ -419,16 +327,13 @@ fn test_module_4() {
     // We group the calls together
     start_module_4(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -444,16 +349,13 @@ fn test_module_5() {
     // We group the calls together
     start_module_5(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -469,16 +371,13 @@ fn test_module_6() {
     // We group the calls together
     start_module_6(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -494,16 +393,13 @@ fn test_module_7() {
     // We group the calls together
     start_module_7(&mut instance);
 }
-fn create_module_8() -> Box<Instance> {
+fn create_module_8() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_8(instance: &mut Instance) {
@@ -519,16 +415,13 @@ fn test_module_8() {
     // We group the calls together
     start_module_8(&mut instance);
 }
-fn create_module_9() -> Box<Instance> {
+fn create_module_9() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_9(instance: &mut Instance) {
@@ -544,16 +437,13 @@ fn test_module_9() {
     // We group the calls together
     start_module_9(&mut instance);
 }
-fn create_module_10() -> Box<Instance> {
+fn create_module_10() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_10(instance: &mut Instance) {
@@ -569,16 +459,13 @@ fn test_module_10() {
     // We group the calls together
     start_module_10(&mut instance);
 }
-fn create_module_11() -> Box<Instance> {
+fn create_module_11() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_11(instance: &mut Instance) {
@@ -594,16 +481,13 @@ fn test_module_11() {
     // We group the calls together
     start_module_11(&mut instance);
 }
-fn create_module_12() -> Box<Instance> {
+fn create_module_12() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_12(instance: &mut Instance) {
@@ -619,16 +503,13 @@ fn test_module_12() {
     // We group the calls together
     start_module_12(&mut instance);
 }
-fn create_module_13() -> Box<Instance> {
+fn create_module_13() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_13(instance: &mut Instance) {
@@ -644,16 +525,13 @@ fn test_module_13() {
     // We group the calls together
     start_module_13(&mut instance);
 }
-fn create_module_14() -> Box<Instance> {
+fn create_module_14() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_14(instance: &mut Instance) {
@@ -669,17 +547,14 @@ fn test_module_14() {
     // We group the calls together
     start_module_14(&mut instance);
 }
-fn create_module_15() -> Box<Instance> {
+fn create_module_15() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_15(instance: &mut Instance) {
@@ -695,17 +570,14 @@ fn test_module_15() {
     // We group the calls together
     start_module_15(&mut instance);
 }
-fn create_module_16() -> Box<Instance> {
+fn create_module_16() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_16(instance: &mut Instance) {
@@ -716,426 +588,249 @@ fn start_module_16(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/block.rs b/lib/runtime/tests/spectests/block.rs
index 85a548cc2..a46965681 100644
--- a/lib/runtime/tests/spectests/block.rs
+++ b/lib/runtime/tests/spectests/block.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func))
@@ -532,11 +536,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -875,10 +876,7 @@ fn c41_l303_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -886,10 +884,7 @@ fn c42_l306_assert_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 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");
 }
@@ -897,10 +892,7 @@ fn c43_l310_assert_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 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");
 }
@@ -908,10 +900,7 @@ fn c44_l314_assert_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 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");
 }
@@ -919,10 +908,7 @@ fn c45_l318_assert_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 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");
 }
@@ -930,10 +916,7 @@ fn c46_l323_assert_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 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");
 }
@@ -941,10 +924,7 @@ fn c47_l329_assert_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 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");
 }
@@ -952,10 +932,7 @@ fn c48_l335_assert_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 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");
 }
@@ -963,10 +940,7 @@ fn c49_l341_assert_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 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");
 }
@@ -974,10 +948,7 @@ fn c50_l348_assert_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 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");
 }
@@ -985,10 +956,7 @@ fn c51_l354_assert_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 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");
 }
@@ -996,10 +964,7 @@ fn c52_l360_assert_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 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");
 }
@@ -1007,10 +972,7 @@ fn c53_l366_assert_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 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");
 }
@@ -1018,10 +980,7 @@ fn c54_l373_assert_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 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");
 }
@@ -1029,10 +988,7 @@ fn c55_l379_assert_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 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");
 }
@@ -1040,10 +996,7 @@ fn c56_l385_assert_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 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");
 }
@@ -1051,10 +1004,7 @@ fn c57_l391_assert_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 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");
 }
@@ -1062,10 +1012,7 @@ fn c58_l398_assert_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 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");
 }
@@ -1073,10 +1020,7 @@ fn c59_l404_assert_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 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");
 }
@@ -1084,10 +1028,7 @@ fn c60_l410_assert_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 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");
 }
@@ -1095,10 +1036,7 @@ fn c61_l416_assert_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 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");
 }
@@ -1106,10 +1044,7 @@ fn c62_l422_assert_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 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");
 }
@@ -1117,10 +1052,7 @@ fn c63_l428_assert_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 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");
 }
@@ -1128,10 +1060,7 @@ fn c64_l434_assert_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 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");
 }
@@ -1139,10 +1068,7 @@ fn c65_l440_assert_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 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");
 }
@@ -1150,10 +1076,7 @@ fn c66_l446_assert_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 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");
 }
@@ -1161,10 +1084,7 @@ fn c67_l452_assert_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 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");
 }
@@ -1172,10 +1092,7 @@ fn c68_l458_assert_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 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");
 }
@@ -1183,10 +1100,7 @@ fn c69_l464_assert_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 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");
 }
@@ -1194,10 +1108,7 @@ fn c70_l471_assert_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 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");
 }
@@ -1205,10 +1116,7 @@ fn c71_l477_assert_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 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");
 }
@@ -1216,10 +1124,7 @@ fn c72_l483_assert_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 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");
 }
@@ -1227,10 +1132,7 @@ fn c73_l489_assert_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 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");
 }
@@ -1238,10 +1140,7 @@ fn c74_l495_assert_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 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");
 }
@@ -1249,10 +1148,7 @@ fn c75_l501_assert_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 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");
 }
@@ -1260,10 +1156,7 @@ fn c76_l507_assert_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 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");
 }
@@ -1271,10 +1164,7 @@ fn c77_l513_assert_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 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");
 }
@@ -1282,10 +1172,7 @@ fn c78_l519_assert_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 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");
 }
@@ -1293,10 +1180,7 @@ fn c79_l525_assert_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 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");
 }
@@ -1304,10 +1188,7 @@ fn c80_l531_assert_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 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");
 }
@@ -1315,10 +1196,7 @@ fn c81_l537_assert_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 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");
 }
@@ -1326,10 +1204,7 @@ fn c82_l544_assert_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 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");
 }
@@ -1337,10 +1212,7 @@ fn c83_l550_assert_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 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");
 }
@@ -1348,10 +1220,7 @@ fn c84_l556_assert_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 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");
 }
@@ -1359,10 +1228,7 @@ fn c85_l562_assert_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 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");
 }
@@ -1370,10 +1236,7 @@ fn c86_l569_assert_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 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");
 }
@@ -1381,10 +1244,7 @@ fn c87_l575_assert_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 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");
 }
@@ -1392,10 +1252,7 @@ fn c88_l581_assert_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 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");
 }
@@ -1403,10 +1260,7 @@ fn c89_l587_assert_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 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");
 }
@@ -1414,10 +1268,7 @@ fn c90_l594_assert_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 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");
 }
@@ -1425,10 +1276,7 @@ fn c91_l600_assert_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 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");
 }
@@ -1436,10 +1284,7 @@ fn c92_l606_assert_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 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");
 }
@@ -1447,10 +1292,7 @@ fn c93_l612_assert_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 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");
 }
@@ -1458,10 +1300,7 @@ fn c94_l619_assert_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 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");
 }
@@ -1469,10 +1308,7 @@ fn c95_l625_assert_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 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");
 }
@@ -1480,10 +1316,7 @@ fn c96_l631_assert_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 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");
 }
@@ -1491,10 +1324,7 @@ fn c97_l637_assert_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 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");
 }
@@ -1502,10 +1332,7 @@ fn c98_l643_assert_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 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");
 }
@@ -1513,10 +1340,7 @@ fn c99_l649_assert_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 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");
 }
@@ -1524,10 +1348,7 @@ fn c100_l655_assert_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 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");
 }
@@ -1535,10 +1356,7 @@ fn c101_l661_assert_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 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");
 }
@@ -1546,10 +1364,7 @@ fn c102_l667_assert_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 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");
 }
@@ -1557,10 +1372,7 @@ fn c103_l673_assert_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 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");
 }
@@ -1568,10 +1380,7 @@ fn c104_l679_assert_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 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");
 }
@@ -1579,10 +1388,7 @@ fn c105_l685_assert_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 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");
 }
@@ -1590,10 +1396,7 @@ fn c106_l692_assert_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 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");
 }
@@ -1601,10 +1404,7 @@ fn c107_l698_assert_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 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");
 }
@@ -1612,10 +1412,7 @@ fn c108_l704_assert_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 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");
 }
@@ -1623,10 +1420,7 @@ fn c109_l710_assert_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 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");
 }
@@ -1634,10 +1428,7 @@ fn c110_l717_assert_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 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");
 }
@@ -1645,10 +1436,7 @@ fn c111_l723_assert_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 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");
 }
@@ -1656,10 +1444,7 @@ fn c112_l729_assert_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 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");
 }
@@ -1667,10 +1452,7 @@ fn c113_l735_assert_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 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");
 }
@@ -1678,10 +1460,7 @@ fn c114_l741_assert_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 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");
 }
@@ -1689,10 +1468,7 @@ fn c115_l747_assert_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 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");
 }
@@ -1700,10 +1476,7 @@ fn c116_l753_assert_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 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");
 }
@@ -1711,10 +1484,7 @@ fn c117_l759_assert_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 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");
 }
@@ -1722,10 +1492,7 @@ fn c118_l765_assert_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 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");
 }
@@ -1733,10 +1500,7 @@ fn c119_l771_assert_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 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");
 }
@@ -1744,10 +1508,7 @@ fn c120_l777_assert_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 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");
 }
@@ -1755,10 +1516,7 @@ fn c121_l783_assert_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 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");
 }
@@ -1766,10 +1524,7 @@ fn c122_l790_assert_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 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");
 }
@@ -1777,10 +1532,7 @@ fn c123_l796_assert_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 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");
 }
@@ -1788,10 +1540,7 @@ fn c124_l802_assert_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 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");
 }
@@ -1799,10 +1548,7 @@ fn c125_l808_assert_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 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");
 }
@@ -1810,10 +1556,7 @@ fn c126_l815_assert_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 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");
 }
@@ -1821,10 +1564,7 @@ fn c127_l821_assert_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 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");
 }
@@ -1832,10 +1572,7 @@ fn c128_l827_assert_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 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");
 }
@@ -1843,10 +1580,7 @@ fn c129_l833_assert_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 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");
 }
@@ -1854,10 +1588,7 @@ fn c130_l840_assert_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 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");
 }
@@ -1865,10 +1596,7 @@ fn c131_l846_assert_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 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");
 }
@@ -1876,10 +1604,7 @@ fn c132_l852_assert_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 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");
 }
@@ -1887,10 +1612,7 @@ fn c133_l858_assert_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 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");
 }
@@ -1898,10 +1620,7 @@ fn c134_l865_assert_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 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");
 }
@@ -1909,10 +1628,7 @@ fn c135_l873_assert_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 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");
 }
@@ -1920,10 +1636,7 @@ fn c136_l881_assert_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 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");
 }
@@ -1931,10 +1644,7 @@ fn c137_l889_assert_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 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");
 }
@@ -1942,10 +1652,7 @@ fn c138_l897_assert_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 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");
 }
@@ -1953,10 +1660,7 @@ fn c139_l905_assert_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 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");
 }
@@ -1964,10 +1668,7 @@ fn c140_l913_assert_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 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");
 }
@@ -1975,10 +1676,7 @@ fn c141_l921_assert_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 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");
 }
@@ -1986,10 +1684,7 @@ fn c142_l929_assert_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 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");
 }
@@ -1997,10 +1692,7 @@ fn c143_l937_assert_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 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");
 }
@@ -2008,10 +1700,7 @@ fn c144_l945_assert_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 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");
 }
@@ -2019,10 +1708,7 @@ fn c145_l953_assert_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 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");
 }
@@ -2030,10 +1716,7 @@ fn c146_l962_assert_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 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");
 }
@@ -2041,10 +1724,7 @@ fn c147_l968_assert_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 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");
 }
@@ -2052,10 +1732,7 @@ fn c148_l974_assert_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 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");
 }
@@ -2063,10 +1740,7 @@ fn c149_l980_assert_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 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");
 }
@@ -2074,10 +1748,7 @@ fn c150_l987_assert_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 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");
 }
@@ -2085,10 +1756,7 @@ fn c151_l993_assert_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 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");
 }
@@ -2096,10 +1764,7 @@ fn c152_l999_assert_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 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");
 }
@@ -2107,10 +1772,7 @@ fn c153_l1005_assert_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 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");
 }
@@ -2118,10 +1780,7 @@ fn c154_l1012_assert_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 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");
 }
@@ -2129,10 +1788,7 @@ fn c155_l1018_assert_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 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");
 }
@@ -2140,10 +1796,7 @@ fn c156_l1024_assert_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 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");
 }
@@ -2151,10 +1804,7 @@ fn c157_l1030_assert_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 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");
 }
@@ -2162,10 +1812,7 @@ fn c158_l1036_assert_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 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");
 }
@@ -2173,10 +1820,7 @@ fn c159_l1042_assert_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 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");
 }
@@ -2184,10 +1828,7 @@ fn c160_l1048_assert_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 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");
 }
@@ -2195,10 +1836,7 @@ fn c161_l1054_assert_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 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");
 }
@@ -2206,10 +1844,7 @@ fn c162_l1060_assert_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 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");
 }
@@ -2217,10 +1852,7 @@ fn c163_l1066_assert_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 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");
 }
@@ -2228,10 +1860,7 @@ fn c164_l1072_assert_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 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");
 }
@@ -2239,28 +1868,17 @@ fn c165_l1078_assert_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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/br.rs b/lib/runtime/tests/spectests/br.rs
index b83ed0993..bc22ca941 100644
--- a/lib/runtime/tests/spectests/br.rs
+++ b/lib/runtime/tests/spectests/br.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32 i32) (result i32)))
       (type (;1;) (func))
@@ -564,11 +568,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -803,10 +804,7 @@ fn c28_l369_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -814,10 +812,7 @@ fn c29_l371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -825,10 +820,7 @@ fn c30_l372_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -836,10 +828,7 @@ fn c31_l373_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1095,10 +1084,7 @@ fn c63_l417_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -1106,10 +1092,7 @@ fn c64_l420_assert_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 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");
 }
@@ -1117,10 +1100,7 @@ fn c65_l427_assert_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 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");
 }
@@ -1128,10 +1108,7 @@ fn c66_l433_assert_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 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");
 }
@@ -1139,9 +1116,7 @@ fn c67_l439_assert_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 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");
 }
@@ -1149,10 +1124,7 @@ fn c68_l446_assert_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 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");
 }
@@ -1160,10 +1132,7 @@ fn c69_l450_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/br_if.rs b/lib/runtime/tests/spectests/br_if.rs
index 293cc3a4b..7724e99f2 100644
--- a/lib/runtime/tests/spectests/br_if.rs
+++ b/lib/runtime/tests/spectests/br_if.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32 i32) (result i32)))
       (type (;1;) (func))
@@ -576,11 +580,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -1223,10 +1224,7 @@ fn c79_l429_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -1234,10 +1232,7 @@ fn c80_l432_assert_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 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");
 }
@@ -1245,10 +1240,7 @@ fn c81_l436_assert_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 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");
 }
@@ -1256,10 +1248,7 @@ fn c82_l440_assert_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 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");
 }
@@ -1267,10 +1256,7 @@ fn c83_l444_assert_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 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");
 }
@@ -1278,10 +1264,7 @@ fn c84_l449_assert_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 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");
 }
@@ -1289,10 +1272,7 @@ fn c85_l453_assert_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 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");
 }
@@ -1300,10 +1280,7 @@ fn c86_l457_assert_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 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");
 }
@@ -1311,10 +1288,7 @@ fn c87_l461_assert_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 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");
 }
@@ -1322,10 +1296,7 @@ fn c88_l466_assert_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 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");
 }
@@ -1333,10 +1304,7 @@ fn c89_l472_assert_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 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");
 }
@@ -1344,10 +1312,7 @@ fn c90_l478_assert_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 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");
 }
@@ -1355,10 +1320,7 @@ fn c91_l484_assert_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 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");
 }
@@ -1366,10 +1328,7 @@ fn c92_l491_assert_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 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");
 }
@@ -1377,10 +1336,7 @@ fn c93_l497_assert_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 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");
 }
@@ -1388,10 +1344,7 @@ fn c94_l503_assert_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 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");
 }
@@ -1399,10 +1352,7 @@ fn c95_l511_assert_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 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");
 }
@@ -1410,10 +1360,7 @@ fn c96_l520_assert_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 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");
 }
@@ -1421,10 +1368,7 @@ fn c97_l526_assert_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 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");
 }
@@ -1432,10 +1376,7 @@ fn c98_l532_assert_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 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");
 }
@@ -1443,10 +1384,7 @@ fn c99_l538_assert_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 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");
 }
@@ -1454,10 +1392,7 @@ fn c100_l544_assert_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 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");
 }
@@ -1465,10 +1400,7 @@ fn c101_l551_assert_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 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");
 }
@@ -1476,10 +1408,7 @@ fn c102_l555_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/br_table.rs b/lib/runtime/tests/spectests/br_table.rs
index e9984f0b5..6f00af74c 100644
--- a/lib/runtime/tests/spectests/br_table.rs
+++ b/lib/runtime/tests/spectests/br_table.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32 i32) (result i32)))
       (type (;1;) (func))
@@ -783,11 +787,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -1438,10 +1439,7 @@ fn c80_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1449,10 +1447,7 @@ fn c81_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1460,10 +1455,7 @@ fn c82_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1471,10 +1463,7 @@ fn c83_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1954,10 +1943,7 @@ fn c143_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1981,10 +1967,7 @@ fn c146_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -1992,10 +1975,7 @@ fn c147_l1429_assert_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 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");
 }
@@ -2003,10 +1983,7 @@ fn c148_l1436_assert_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 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");
 }
@@ -2014,10 +1991,7 @@ fn c149_l1442_assert_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 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");
 }
@@ -2025,10 +1999,7 @@ fn c150_l1450_assert_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 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");
 }
@@ -2036,10 +2007,7 @@ fn c151_l1462_assert_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 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");
 }
@@ -2047,10 +2015,7 @@ fn c152_l1468_assert_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 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");
 }
@@ -2058,10 +2023,7 @@ fn c153_l1474_assert_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 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");
 }
@@ -2069,10 +2031,7 @@ fn c154_l1480_assert_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 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");
 }
@@ -2080,10 +2039,7 @@ fn c155_l1486_assert_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 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");
 }
@@ -2091,10 +2047,7 @@ fn c156_l1495_assert_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 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");
 }
@@ -2102,10 +2055,7 @@ fn c157_l1501_assert_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 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");
 }
@@ -2113,10 +2063,7 @@ fn c158_l1507_assert_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 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");
 }
@@ -2124,10 +2071,7 @@ fn c159_l1514_assert_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 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");
 }
@@ -2135,10 +2079,7 @@ fn c160_l1520_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/break_drop.rs b/lib/runtime/tests/spectests/break_drop.rs
index 0e7ff74c1..5038eb4b6 100644
--- a/lib/runtime/tests/spectests/break_drop.rs
+++ b/lib/runtime/tests/spectests/break_drop.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -37,11 +41,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
diff --git a/lib/runtime/tests/spectests/call.rs b/lib/runtime/tests/spectests/call.rs
index 5c2c156bb..c7b0f418d 100644
--- a/lib/runtime/tests/spectests/call.rs
+++ b/lib/runtime/tests/spectests/call.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func (result i32)))
@@ -318,11 +322,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -682,14 +683,14 @@ fn c45_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c46_l261_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -776,10 +777,7 @@ fn c56_l273_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -787,10 +785,7 @@ fn c57_l278_assert_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 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");
 }
@@ -798,10 +793,7 @@ fn c58_l285_assert_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 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");
 }
@@ -809,10 +801,7 @@ fn c59_l293_assert_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 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");
 }
@@ -820,10 +809,7 @@ fn c60_l300_assert_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 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");
 }
@@ -831,10 +817,7 @@ fn c61_l307_assert_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 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");
 }
@@ -842,10 +825,7 @@ fn c62_l314_assert_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 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");
 }
@@ -853,10 +833,7 @@ fn c63_l322_assert_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 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");
 }
@@ -864,10 +841,7 @@ fn c64_l329_assert_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 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");
 }
@@ -875,10 +849,7 @@ fn c65_l336_assert_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 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");
 }
@@ -886,9 +857,7 @@ fn c66_l343_assert_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 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");
 }
@@ -896,10 +865,7 @@ fn c67_l354_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/call_indirect.rs b/lib/runtime/tests/spectests/call_indirect.rs
index cf6e1d133..d87514fa0 100644
--- a/lib/runtime/tests/spectests/call_indirect.rs
+++ b/lib/runtime/tests/spectests/call_indirect.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func (result i32)))
@@ -514,11 +518,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -1301,226 +1302,95 @@ fn c98_l534_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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");
 }
@@ -1528,10 +1398,7 @@ fn c110_l661_assert_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 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");
 }
@@ -1539,10 +1406,7 @@ fn c111_l669_assert_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 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");
 }
@@ -1550,10 +1414,7 @@ fn c112_l677_assert_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 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");
 }
@@ -1561,10 +1422,7 @@ fn c113_l686_assert_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 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");
 }
@@ -1572,10 +1430,7 @@ fn c114_l694_assert_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 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");
 }
@@ -1583,10 +1438,7 @@ fn c115_l702_assert_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 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");
 }
@@ -1594,10 +1446,7 @@ fn c116_l710_assert_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 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");
 }
@@ -1605,10 +1454,7 @@ fn c117_l721_assert_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 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");
 }
@@ -1616,10 +1462,7 @@ fn c118_l729_assert_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 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");
 }
@@ -1627,10 +1470,7 @@ fn c119_l738_assert_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 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");
 }
@@ -1638,10 +1478,7 @@ fn c120_l748_assert_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 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");
 }
@@ -1649,10 +1486,7 @@ fn c121_l758_assert_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 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");
 }
@@ -1660,10 +1494,7 @@ fn c122_l768_assert_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 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");
 }
@@ -1671,10 +1502,7 @@ fn c123_l782_assert_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 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");
 }
@@ -1682,9 +1510,7 @@ fn c124_l789_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/comments.rs b/lib/runtime/tests/spectests/comments.rs
index bd280977e..ced99142f 100644
--- a/lib/runtime/tests/spectests/comments.rs
+++ b/lib/runtime/tests/spectests/comments.rs
@@ -5,25 +5,26 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 10
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -39,15 +40,12 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -63,15 +61,12 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -87,15 +82,12 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
diff --git a/lib/runtime/tests/spectests/const_.rs b/lib/runtime/tests/spectests/const_.rs
index 610b6a020..edcd68274 100644
--- a/lib/runtime/tests/spectests/const_.rs
+++ b/lib/runtime/tests/spectests/const_.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 5
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -23,11 +27,8 @@ fn create_module_1() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -43,7 +44,7 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -51,11 +52,8 @@ fn create_module_2() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -66,29 +64,17 @@ fn start_module_2(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 16
@@ -99,7 +85,7 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -107,11 +93,8 @@ fn create_module_3() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -127,7 +110,7 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -135,11 +118,8 @@ fn create_module_4() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -150,29 +130,17 @@ fn start_module_4(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 27
@@ -183,7 +151,7 @@ fn test_module_4() {
     // We group the calls together
     start_module_4(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -191,11 +159,8 @@ fn create_module_5() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -211,7 +176,7 @@ fn test_module_5() {
     // We group the calls together
     start_module_5(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -219,11 +184,8 @@ fn create_module_6() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -234,31 +196,17 @@ fn start_module_6(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 38
@@ -269,7 +217,7 @@ fn test_module_6() {
     // We group the calls together
     start_module_6(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -277,11 +225,8 @@ fn create_module_7() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -297,7 +242,7 @@ fn test_module_7() {
     // We group the calls together
     start_module_7(&mut instance);
 }
-fn create_module_8() -> Box<Instance> {
+fn create_module_8() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -305,11 +250,8 @@ fn create_module_8() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_8(instance: &mut Instance) {
@@ -320,31 +262,17 @@ fn start_module_8(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 49
@@ -355,7 +283,7 @@ fn test_module_8() {
     // We group the calls together
     start_module_8(&mut instance);
 }
-fn create_module_9() -> Box<Instance> {
+fn create_module_9() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -363,11 +291,8 @@ fn create_module_9() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_9(instance: &mut Instance) {
@@ -383,7 +308,7 @@ fn test_module_9() {
     // We group the calls together
     start_module_9(&mut instance);
 }
-fn create_module_10() -> Box<Instance> {
+fn create_module_10() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -391,11 +316,8 @@ fn create_module_10() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_10(instance: &mut Instance) {
@@ -411,7 +333,7 @@ fn test_module_10() {
     // We group the calls together
     start_module_10(&mut instance);
 }
-fn create_module_11() -> Box<Instance> {
+fn create_module_11() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -419,11 +341,8 @@ fn create_module_11() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_11(instance: &mut Instance) {
@@ -439,7 +358,7 @@ fn test_module_11() {
     // We group the calls together
     start_module_11(&mut instance);
 }
-fn create_module_12() -> Box<Instance> {
+fn create_module_12() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -447,11 +366,8 @@ fn create_module_12() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_12(instance: &mut Instance) {
@@ -467,7 +383,7 @@ fn test_module_12() {
     // We group the calls together
     start_module_12(&mut instance);
 }
-fn create_module_13() -> Box<Instance> {
+fn create_module_13() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -475,11 +391,8 @@ fn create_module_13() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_13(instance: &mut Instance) {
@@ -495,7 +408,7 @@ fn test_module_13() {
     // We group the calls together
     start_module_13(&mut instance);
 }
-fn create_module_14() -> Box<Instance> {
+fn create_module_14() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -503,11 +416,8 @@ fn create_module_14() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_14(instance: &mut Instance) {
@@ -518,57 +428,33 @@ fn start_module_14(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 72
@@ -579,7 +465,7 @@ fn test_module_14() {
     // We group the calls together
     start_module_14(&mut instance);
 }
-fn create_module_15() -> Box<Instance> {
+fn create_module_15() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -587,11 +473,8 @@ fn create_module_15() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_15(instance: &mut Instance) {
@@ -607,7 +490,7 @@ fn test_module_15() {
     // We group the calls together
     start_module_15(&mut instance);
 }
-fn create_module_16() -> Box<Instance> {
+fn create_module_16() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -615,11 +498,8 @@ fn create_module_16() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_16(instance: &mut Instance) {
@@ -630,29 +510,17 @@ fn start_module_16(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 83
@@ -663,7 +531,7 @@ fn test_module_16() {
     // We group the calls together
     start_module_16(&mut instance);
 }
-fn create_module_17() -> Box<Instance> {
+fn create_module_17() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -671,11 +539,8 @@ fn create_module_17() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_17(instance: &mut Instance) {
@@ -691,7 +556,7 @@ fn test_module_17() {
     // We group the calls together
     start_module_17(&mut instance);
 }
-fn create_module_18() -> Box<Instance> {
+fn create_module_18() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -699,11 +564,8 @@ fn create_module_18() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_18(instance: &mut Instance) {
@@ -714,31 +576,17 @@ fn start_module_18(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 94
@@ -749,7 +597,7 @@ fn test_module_18() {
     // We group the calls together
     start_module_18(&mut instance);
 }
-fn create_module_19() -> Box<Instance> {
+fn create_module_19() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -757,11 +605,8 @@ fn create_module_19() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_19(instance: &mut Instance) {
@@ -777,7 +622,7 @@ fn test_module_19() {
     // We group the calls together
     start_module_19(&mut instance);
 }
-fn create_module_20() -> Box<Instance> {
+fn create_module_20() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -785,11 +630,8 @@ fn create_module_20() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_20(instance: &mut Instance) {
@@ -805,7 +647,7 @@ fn test_module_20() {
     // We group the calls together
     start_module_20(&mut instance);
 }
-fn create_module_21() -> Box<Instance> {
+fn create_module_21() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -813,11 +655,8 @@ fn create_module_21() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_21(instance: &mut Instance) {
@@ -833,7 +672,7 @@ fn test_module_21() {
     // We group the calls together
     start_module_21(&mut instance);
 }
-fn create_module_22() -> Box<Instance> {
+fn create_module_22() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -841,11 +680,8 @@ fn create_module_22() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_22(instance: &mut Instance) {
@@ -861,7 +697,7 @@ fn test_module_22() {
     // We group the calls together
     start_module_22(&mut instance);
 }
-fn create_module_23() -> Box<Instance> {
+fn create_module_23() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -869,11 +705,8 @@ fn create_module_23() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_23(instance: &mut Instance) {
@@ -889,7 +722,7 @@ fn test_module_23() {
     // We group the calls together
     start_module_23(&mut instance);
 }
-fn create_module_24() -> Box<Instance> {
+fn create_module_24() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -897,11 +730,8 @@ fn create_module_24() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_24(instance: &mut Instance) {
@@ -912,59 +742,33 @@ fn start_module_24(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 117
@@ -975,7 +779,7 @@ fn test_module_24() {
     // We group the calls together
     start_module_24(&mut instance);
 }
-fn create_module_25() -> Box<Instance> {
+fn create_module_25() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -983,11 +787,8 @@ fn create_module_25() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_25(instance: &mut Instance) {
@@ -1003,7 +804,7 @@ fn test_module_25() {
     // We group the calls together
     start_module_25(&mut instance);
 }
-fn create_module_26() -> Box<Instance> {
+fn create_module_26() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -1011,11 +812,8 @@ fn create_module_26() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_26(instance: &mut Instance) {
@@ -1026,29 +824,17 @@ fn start_module_26(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 128
@@ -1059,7 +845,7 @@ fn test_module_26() {
     // We group the calls together
     start_module_26(&mut instance);
 }
-fn create_module_27() -> Box<Instance> {
+fn create_module_27() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -1067,11 +853,8 @@ fn create_module_27() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_27(instance: &mut Instance) {
@@ -1087,7 +870,7 @@ fn test_module_27() {
     // We group the calls together
     start_module_27(&mut instance);
 }
-fn create_module_28() -> Box<Instance> {
+fn create_module_28() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0)
@@ -1095,11 +878,8 @@ fn create_module_28() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_28(instance: &mut Instance) {
@@ -1110,55 +890,17 @@ fn start_module_28(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/conversions.rs b/lib/runtime/tests/spectests/conversions.rs
index 54e565378..da94692c1 100644
--- a/lib/runtime/tests/spectests/conversions.rs
+++ b/lib/runtime/tests/spectests/conversions.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i64)))
       (type (;1;) (func (param i64) (result i32)))
@@ -131,11 +135,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -354,12 +355,7 @@ fn c26_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i32.trunc_s_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -367,12 +363,7 @@ fn c27_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -461,14 +452,14 @@ fn c38_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c39_l70_assert_trap() {
     let mut instance = create_module_1();
-    let result = c39_l70_action_invoke(&mut *instance);
+    let result = c39_l70_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -476,14 +467,14 @@ fn c39_l70_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c40_l71_assert_trap() {
     let mut instance = create_module_1();
-    let result = c40_l71_action_invoke(&mut *instance);
+    let result = c40_l71_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -491,14 +482,14 @@ fn c40_l71_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c41_l72_assert_trap() {
     let mut instance = create_module_1();
-    let result = c41_l72_action_invoke(&mut *instance);
+    let result = c41_l72_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -506,14 +497,14 @@ fn c41_l72_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c42_l73_assert_trap() {
     let mut instance = create_module_1();
-    let result = c42_l73_action_invoke(&mut *instance);
+    let result = c42_l73_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -521,14 +512,14 @@ fn c42_l73_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c43_l74_assert_trap() {
     let mut instance = create_module_1();
-    let result = c43_l74_action_invoke(&mut *instance);
+    let result = c43_l74_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -536,14 +527,14 @@ fn c43_l74_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c44_l75_assert_trap() {
     let mut instance = create_module_1();
-    let result = c44_l75_action_invoke(&mut *instance);
+    let result = c44_l75_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -551,14 +542,14 @@ fn c44_l75_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c45_l76_assert_trap() {
     let mut instance = create_module_1();
-    let result = c45_l76_action_invoke(&mut *instance);
+    let result = c45_l76_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -566,14 +557,14 @@ fn c45_l76_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c46_l77_assert_trap() {
     let mut instance = create_module_1();
-    let result = c46_l77_action_invoke(&mut *instance);
+    let result = c46_l77_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -596,12 +587,7 @@ fn c48_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i32.trunc_u_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -609,12 +595,7 @@ fn c49_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -695,14 +676,14 @@ fn c59_l91_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c60_l92_assert_trap() {
     let mut instance = create_module_1();
-    let result = c60_l92_action_invoke(&mut *instance);
+    let result = c60_l92_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -710,14 +691,14 @@ fn c60_l92_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c61_l93_assert_trap() {
     let mut instance = create_module_1();
-    let result = c61_l93_action_invoke(&mut *instance);
+    let result = c61_l93_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -725,14 +706,14 @@ fn c61_l93_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c62_l94_assert_trap() {
     let mut instance = create_module_1();
-    let result = c62_l94_action_invoke(&mut *instance);
+    let result = c62_l94_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -740,14 +721,14 @@ fn c62_l94_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c63_l95_assert_trap() {
     let mut instance = create_module_1();
-    let result = c63_l95_action_invoke(&mut *instance);
+    let result = c63_l95_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -755,14 +736,14 @@ fn c63_l95_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c64_l96_assert_trap() {
     let mut instance = create_module_1();
-    let result = c64_l96_action_invoke(&mut *instance);
+    let result = c64_l96_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -770,14 +751,14 @@ fn c64_l96_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c65_l97_assert_trap() {
     let mut instance = create_module_1();
-    let result = c65_l97_action_invoke(&mut *instance);
+    let result = c65_l97_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -785,14 +766,14 @@ fn c65_l97_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c66_l98_assert_trap() {
     let mut instance = create_module_1();
-    let result = c66_l98_action_invoke(&mut *instance);
+    let result = c66_l98_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -800,14 +781,14 @@ fn c66_l98_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c67_l99_assert_trap() {
     let mut instance = create_module_1();
-    let result = c67_l99_action_invoke(&mut *instance);
+    let result = c67_l99_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -927,14 +908,14 @@ fn c81_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c82_l115_assert_trap() {
     let mut instance = create_module_1();
-    let result = c82_l115_action_invoke(&mut *instance);
+    let result = c82_l115_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -942,14 +923,14 @@ fn c82_l115_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c83_l116_assert_trap() {
     let mut instance = create_module_1();
-    let result = c83_l116_action_invoke(&mut *instance);
+    let result = c83_l116_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -957,14 +938,14 @@ fn c83_l116_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c84_l117_assert_trap() {
     let mut instance = create_module_1();
-    let result = c84_l117_action_invoke(&mut *instance);
+    let result = c84_l117_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -972,86 +953,74 @@ fn c84_l117_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c85_l118_assert_trap() {
     let mut instance = create_module_1();
-    let result = c85_l118_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c86_l119_assert_trap() {
     let mut instance = create_module_1();
-    let result = c86_l119_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(9219994337134247936))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c87_l120_assert_trap() {
     let mut instance = create_module_1();
-    let result = c87_l120_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(18444492273895866368))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c88_l121_assert_trap() {
     let mut instance = create_module_1();
-    let result = c88_l121_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(18443366373989023744))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c89_l122_assert_trap() {
     let mut instance = create_module_1();
-    let result = c89_l122_action_invoke(&mut *instance);
+    let result = c89_l122_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1171,14 +1140,14 @@ fn c103_l137_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c104_l138_assert_trap() {
     let mut instance = create_module_1();
-    let result = c104_l138_action_invoke(&mut *instance);
+    let result = c104_l138_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1186,14 +1155,14 @@ fn c104_l138_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c105_l139_assert_trap() {
     let mut instance = create_module_1();
-    let result = c105_l139_action_invoke(&mut *instance);
+    let result = c105_l139_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1201,32 +1170,29 @@ fn c105_l139_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c106_l140_assert_trap() {
     let mut instance = create_module_1();
-    let result = c106_l140_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_u_f64", &[Value::F64((1000000000000000000000000000000.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c107_l141_assert_trap() {
     let mut instance = create_module_1();
-    let result = c107_l141_action_invoke(&mut *instance);
+    let result = c107_l141_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1234,14 +1200,14 @@ fn c107_l141_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c108_l142_assert_trap() {
     let mut instance = create_module_1();
-    let result = c108_l142_action_invoke(&mut *instance);
+    let result = c108_l142_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1249,14 +1215,14 @@ fn c108_l142_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c109_l143_assert_trap() {
     let mut instance = create_module_1();
-    let result = c109_l143_action_invoke(&mut *instance);
+    let result = c109_l143_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1264,86 +1230,74 @@ fn c109_l143_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c110_l144_assert_trap() {
     let mut instance = create_module_1();
-    let result = c110_l144_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c111_l145_assert_trap() {
     let mut instance = create_module_1();
-    let result = c111_l145_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(9219994337134247936))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c112_l146_assert_trap() {
     let mut instance = create_module_1();
-    let result = c112_l146_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(18444492273895866368))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c113_l147_assert_trap() {
     let mut instance = create_module_1();
-    let result = c113_l147_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(18443366373989023744))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c114_l148_assert_trap() {
     let mut instance = create_module_1();
-    let result = c114_l148_action_invoke(&mut *instance);
+    let result = c114_l148_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1366,12 +1320,7 @@ fn c116_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i64.trunc_s_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
     result.map(|_| ())
 }
@@ -1379,12 +1328,7 @@ fn c117_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
     result.map(|_| ())
 }
@@ -1480,10 +1424,7 @@ fn c129_l164_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-9223372000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64))));
     result.map(|_| ())
 }
@@ -1492,32 +1433,29 @@ fn c130_l165_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c131_l166_assert_trap() {
     let mut instance = create_module_1();
-    let result = c131_l166_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-9223373000000000000.0f32))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c132_l167_assert_trap() {
     let mut instance = create_module_1();
-    let result = c132_l167_action_invoke(&mut *instance);
+    let result = c132_l167_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1525,14 +1463,14 @@ fn c132_l167_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c133_l168_assert_trap() {
     let mut instance = create_module_1();
-    let result = c133_l168_action_invoke(&mut *instance);
+    let result = c133_l168_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1540,14 +1478,14 @@ fn c133_l168_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c134_l169_assert_trap() {
     let mut instance = create_module_1();
-    let result = c134_l169_action_invoke(&mut *instance);
+    let result = c134_l169_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1555,14 +1493,14 @@ fn c134_l169_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c135_l170_assert_trap() {
     let mut instance = create_module_1();
-    let result = c135_l170_action_invoke(&mut *instance);
+    let result = c135_l170_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1570,14 +1508,14 @@ fn c135_l170_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c136_l171_assert_trap() {
     let mut instance = create_module_1();
-    let result = c136_l171_action_invoke(&mut *instance);
+    let result = c136_l171_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1585,14 +1523,14 @@ fn c136_l171_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c137_l172_assert_trap() {
     let mut instance = create_module_1();
-    let result = c137_l172_action_invoke(&mut *instance);
+    let result = c137_l172_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1600,14 +1538,14 @@ fn c137_l172_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c138_l173_assert_trap() {
     let mut instance = create_module_1();
-    let result = c138_l173_action_invoke(&mut *instance);
+    let result = c138_l173_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1630,12 +1568,7 @@ fn c140_l176_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i64.trunc_u_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
     result.map(|_| ())
 }
@@ -1643,12 +1576,7 @@ fn c141_l177_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
     result.map(|_| ())
 }
@@ -1688,10 +1616,7 @@ fn c146_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.trunc_u_f32", &[Value::F32((18446743000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I64(-1099511627776 as i64))));
     result.map(|_| ())
 }
@@ -1715,18 +1640,15 @@ fn c149_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-
+    let result = instance.call("i64.trunc_u_f32", &[Value::F32((18446744000000000000.0f32))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c150_l186_assert_trap() {
     let mut instance = create_module_1();
-    let result = c150_l186_action_invoke(&mut *instance);
+    let result = c150_l186_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1734,14 +1656,14 @@ fn c150_l186_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c151_l187_assert_trap() {
     let mut instance = create_module_1();
-    let result = c151_l187_action_invoke(&mut *instance);
+    let result = c151_l187_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1749,14 +1671,14 @@ fn c151_l187_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c152_l188_assert_trap() {
     let mut instance = create_module_1();
-    let result = c152_l188_action_invoke(&mut *instance);
+    let result = c152_l188_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1764,14 +1686,14 @@ fn c152_l188_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c153_l189_assert_trap() {
     let mut instance = create_module_1();
-    let result = c153_l189_action_invoke(&mut *instance);
+    let result = c153_l189_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1779,14 +1701,14 @@ fn c153_l189_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c154_l190_assert_trap() {
     let mut instance = create_module_1();
-    let result = c154_l190_action_invoke(&mut *instance);
+    let result = c154_l190_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1794,14 +1716,14 @@ fn c154_l190_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c155_l191_assert_trap() {
     let mut instance = create_module_1();
-    let result = c155_l191_action_invoke(&mut *instance);
+    let result = c155_l191_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1809,14 +1731,14 @@ fn c155_l191_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c156_l192_assert_trap() {
     let mut instance = create_module_1();
-    let result = c156_l192_action_invoke(&mut *instance);
+    let result = c156_l192_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1824,14 +1746,14 @@ fn c156_l192_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c157_l193_assert_trap() {
     let mut instance = create_module_1();
-    let result = c157_l193_action_invoke(&mut *instance);
+    let result = c157_l193_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1958,10 +1880,7 @@ fn c172_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-9223372036854776000.0f64))]);
     assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64))));
     result.map(|_| ())
 }
@@ -1970,32 +1889,29 @@ fn c173_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c174_l211_assert_trap() {
     let mut instance = create_module_1();
-    let result = c174_l211_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-9223372036854778000.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c175_l212_assert_trap() {
     let mut instance = create_module_1();
-    let result = c175_l212_action_invoke(&mut *instance);
+    let result = c175_l212_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2003,14 +1919,14 @@ fn c175_l212_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c176_l213_assert_trap() {
     let mut instance = create_module_1();
-    let result = c176_l213_action_invoke(&mut *instance);
+    let result = c176_l213_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2018,86 +1934,74 @@ fn c176_l213_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c177_l214_assert_trap() {
     let mut instance = create_module_1();
-    let result = c177_l214_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c178_l215_assert_trap() {
     let mut instance = create_module_1();
-    let result = c178_l215_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(9219994337134247936))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c179_l216_assert_trap() {
     let mut instance = create_module_1();
-    let result = c179_l216_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(18444492273895866368))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c180_l217_assert_trap() {
     let mut instance = create_module_1();
-    let result = c180_l217_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(18443366373989023744))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c181_l218_assert_trap() {
     let mut instance = create_module_1();
-    let result = c181_l218_action_invoke(&mut *instance);
+    let result = c181_l218_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2176,10 +2080,7 @@ fn c190_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.trunc_u_f64", &[Value::F64((18446744073709550000.0f64))]);
     assert_eq!(result, Ok(Some(Value::I64(-2048 as i64))));
     result.map(|_| ())
 }
@@ -2227,18 +2128,15 @@ fn c196_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-
+    let result = instance.call("i64.trunc_u_f64", &[Value::F64((18446744073709552000.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c197_l235_assert_trap() {
     let mut instance = create_module_1();
-    let result = c197_l235_action_invoke(&mut *instance);
+    let result = c197_l235_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2246,14 +2144,14 @@ fn c197_l235_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c198_l236_assert_trap() {
     let mut instance = create_module_1();
-    let result = c198_l236_action_invoke(&mut *instance);
+    let result = c198_l236_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2261,14 +2159,14 @@ fn c198_l236_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c199_l237_assert_trap() {
     let mut instance = create_module_1();
-    let result = c199_l237_action_invoke(&mut *instance);
+    let result = c199_l237_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2276,86 +2174,74 @@ fn c199_l237_assert_trap() {
 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)]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c200_l238_assert_trap() {
     let mut instance = create_module_1();
-    let result = c200_l238_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c201_l239_assert_trap() {
     let mut instance = create_module_1();
-    let result = c201_l239_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(9219994337134247936))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c202_l240_assert_trap() {
     let mut instance = create_module_1();
-    let result = c202_l240_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(18444492273895866368))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c203_l241_assert_trap() {
     let mut instance = create_module_1();
-    let result = c203_l241_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(18443366373989023744))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c204_l242_assert_trap() {
     let mut instance = create_module_1();
-    let result = c204_l242_action_invoke(&mut *instance);
+    let result = c204_l242_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2466,10 +2352,7 @@ fn c217_l258_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f32.convert_s_i64", &[Value::I64(9223372036854775807 as i64)]);
     assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2477,10 +2360,7 @@ fn c218_l259_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f32.convert_s_i64", &[Value::I64(-9223372036854775808 as i64)]);
     assert_eq!(result, Ok(Some(Value::F32((-9223372000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2600,10 +2480,7 @@ fn c233_l277_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.convert_s_i64", &[Value::I64(9223372036854775807 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64)))));
     result.map(|_| ())
 }
@@ -2611,10 +2488,7 @@ fn c234_l278_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.convert_s_i64", &[Value::I64(-9223372036854775808 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((-9223372036854776000.0f64)))));
     result.map(|_| ())
 }
@@ -2790,10 +2664,7 @@ fn c256_l304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f32.convert_u_i64", &[Value::I64(9223372036854775807 as i64)]);
     assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2801,10 +2672,7 @@ fn c257_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f32.convert_u_i64", &[Value::I64(-9223372036854775808 as i64)]);
     assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2892,10 +2760,7 @@ fn c268_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.convert_u_i64", &[Value::I64(9223372036854775807 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64)))));
     result.map(|_| ())
 }
@@ -2903,10 +2768,7 @@ fn c269_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854775808 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64)))));
     result.map(|_| ())
 }
@@ -2922,10 +2784,7 @@ fn c271_l322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774784 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64)))));
     result.map(|_| ())
 }
@@ -2933,10 +2792,7 @@ fn c272_l323_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774783 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64)))));
     result.map(|_| ())
 }
@@ -2944,10 +2800,7 @@ fn c273_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774782 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64)))));
     result.map(|_| ())
 }
@@ -3011,36 +2864,16 @@ fn c281_l334_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.000000000000000000000000000000000000000000001401298464324817f64)
-        )))
-    );
+    let result = instance.call("f64.promote_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000001401298464324817f64)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.000000000000000000000000000000000000000000001401298464324817f64)
-        )))
-    );
+    let result = instance.call("f64.promote_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000001401298464324817f64)))));
     result.map(|_| ())
 }
 
@@ -3063,66 +2896,32 @@ fn c285_l338_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-340282346638528860000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.promote_f32", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F64((-340282346638528860000000000000000000000.0f64)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (340282346638528860000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.promote_f32", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F64((340282346638528860000000000000000000000.0f64)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.000000000000000000000000000000000001504632769052528f64)
-        )))
-    );
+    let result = instance.call("f64.promote_f32", &[Value::F32((0.0000000000000000000000000000000000015046328f32))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000001504632769052528f64)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (66382536710104395000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.promote_f32", &[Value::F32((66382537000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F64((66382536710104395000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -3144,69 +2943,45 @@ fn c291_l346_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c292_l347_assert_return_canonical_nan");
+    println!("Executing function {}", "c292_l347_assert_return_canonical_nan");
+    let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c292_l347_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c293_l348_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c293_l348_assert_return_arithmetic_nan");
+    let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c293_l348_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c294_l349_assert_return_canonical_nan");
+    println!("Executing function {}", "c294_l349_assert_return_canonical_nan");
+    let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c294_l349_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c295_l350_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c295_l350_assert_return_arithmetic_nan");
+    let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c295_l350_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -3261,246 +3036,119 @@ fn c301_l357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000011754942807573643f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000011754942807573643f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000011754942807573642f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000011754942807573642f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000000000001401298464324817f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000000000001401298464324817f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282330000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((340282336497324060000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282330000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-340282336497324060000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282330000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((340282336497324100000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-340282336497324100000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((340282346638528860000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-340282346638528860000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((340282356779733620000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-340282356779733620000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((340282356779733660000000000000000000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3508,10 +3156,7 @@ fn c316_l372_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-340282356779733660000000000000000000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3519,34 +3164,16 @@ fn c317_l373_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.0000000000000000000000000000000000015046328f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000001504632769052528f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000015046328f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (66382537000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((66382536710104395000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((66382537000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -3657,50 +3284,24 @@ fn c332_l388_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((424258450000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((424258443299142700000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((424258450000000000000000000000000.0f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.00000000000000000000000000000000015692621f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000001569262107843488f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000015692621f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000010551773f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000010551773688605172f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000010551773f32)))));
     result.map(|_| ())
 }
 
@@ -3715,94 +3316,52 @@ fn c336_l392_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-9063376000000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-9063376370095757000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-9063376000000000000000000000000000.0f32)))));
     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))],
-        )
-        .unwrap()
-        .expect("Missing result in c338_l394_assert_return_canonical_nan");
+    println!("Executing function {}", "c338_l394_assert_return_canonical_nan");
+    let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c338_l394_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c339_l395_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c339_l395_assert_return_arithmetic_nan");
+    let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c339_l395_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c340_l396_assert_return_canonical_nan");
+    println!("Executing function {}", "c340_l396_assert_return_canonical_nan");
+    let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c340_l396_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c341_l397_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c341_l397_assert_return_arithmetic_nan");
+    let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c341_l397_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -3825,12 +3384,7 @@ fn c343_l399_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000000000000000007006492321624085f64))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -3838,12 +3392,7 @@ fn c344_l400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-0.0000000000000000000000000000000000000000000007006492321624085f64))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -3851,36 +3400,16 @@ fn c345_l401_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000000000000000007006492321624087f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("f32.demote_f64", &[Value::F64((-0.0000000000000000000000000000000000000000000007006492321624087f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -3904,12 +3433,7 @@ fn c349_l406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -3918,15 +3442,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -3934,12 +3455,7 @@ fn c351_l408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000016535997f32)))));
     result.map(|_| ())
 }
 
@@ -3947,12 +3463,7 @@ fn c352_l409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -3977,15 +3488,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -3994,15 +3502,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -4011,15 +3516,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -4028,15 +3530,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -4061,25 +3560,19 @@ 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);
-    }
+                                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)],
-    );
+    let result = instance.call("f64.reinterpret_i64", &[Value::I64(-9223372036854775808 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -4095,10 +3588,7 @@ fn c364_l422_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.reinterpret_i64", &[Value::I64(-9223372036854775807 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)))));
     result.map(|_| ())
 }
@@ -4106,10 +3596,7 @@ fn c365_l423_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.reinterpret_i64", &[Value::I64(9218868437227405312 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -4117,10 +3604,7 @@ fn c366_l424_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("f64.reinterpret_i64", &[Value::I64(-4503599627370496 as i64)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4128,80 +3612,56 @@ fn c367_l425_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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);
-    }
+                                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 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);
-    }
+                                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 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);
-    }
+                                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 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);
-    }
+                                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(|_| ())
 }
 
@@ -4224,12 +3684,7 @@ fn c373_l432_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4237,10 +3692,7 @@ fn c374_l433_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4294967295))]);
     assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
     result.map(|_| ())
 }
@@ -4248,12 +3700,7 @@ fn c375_l434_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(-2147483647 as i32))));
     result.map(|_| ())
 }
@@ -4277,10 +3724,7 @@ fn c378_l437_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(2139095039 as i32))));
     result.map(|_| ())
 }
@@ -4288,10 +3732,7 @@ fn c379_l438_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(-8388609 as i32))));
     result.map(|_| ())
 }
@@ -4315,10 +3756,7 @@ fn c382_l441_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32))));
     result.map(|_| ())
 }
@@ -4326,10 +3764,7 @@ fn c383_l442_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(-4194304 as i32))));
     result.map(|_| ())
 }
@@ -4337,10 +3772,7 @@ fn c384_l443_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32))));
     result.map(|_| ())
 }
@@ -4348,10 +3780,7 @@ fn c385_l444_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(-6291456 as i32))));
     result.map(|_| ())
 }
@@ -4383,10 +3812,7 @@ fn c389_l449_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18446744073709551615))]);
     assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
     result.map(|_| ())
 }
@@ -4450,10 +3876,7 @@ fn c397_l457_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64))));
     result.map(|_| ())
 }
@@ -4461,10 +3884,7 @@ fn c398_l458_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I64(-2251799813685248 as i64))));
     result.map(|_| ())
 }
@@ -4472,10 +3892,7 @@ fn c399_l459_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64))));
     result.map(|_| ())
 }
@@ -4483,10 +3900,7 @@ fn c400_l460_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I64(-3377699720527872 as i64))));
     result.map(|_| ())
 }
diff --git a/lib/runtime/tests/spectests/custom.rs b/lib/runtime/tests/spectests/custom.rs
index 52aa9b461..f7989a90b 100644
--- a/lib/runtime/tests/spectests/custom.rs
+++ b/lib/runtime/tests/spectests/custom.rs
@@ -5,25 +5,26 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -39,15 +40,12 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -63,7 +61,7 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (func (;0;) (type 0) (param i32 i32) (result i32)
@@ -73,11 +71,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -90,10 +85,7 @@ fn start_module_3(instance: &mut Instance) {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 69
@@ -101,10 +93,7 @@ fn c3_l61_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 77
@@ -112,59 +101,31 @@ fn c4_l69_assert_malformed() {
 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 115
@@ -172,10 +133,7 @@ fn c8_l102_assert_malformed() {
 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/data.rs b/lib/runtime/tests/spectests/data.rs
index 59702266c..6c8de4735 100644
--- a/lib/runtime/tests/spectests/data.rs
+++ b/lib/runtime/tests/spectests/data.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 5
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (memory (;0;) 1)
       (data (;0;) (i32.const 0) \"\")
@@ -32,11 +36,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -52,17 +53,14 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -78,17 +76,14 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -104,7 +99,7 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (memory (;0;) 1)
       (data (;0;) (i32.const 0) \"a\")
@@ -114,11 +109,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -134,7 +126,7 @@ fn test_module_4() {
     // We group the calls together
     start_module_4(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (import \"spectest\" \"memory\" (memory (;0;) 1))
       (data (;0;) (i32.const 0) \"a\")
@@ -145,11 +137,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -165,18 +154,15 @@ fn test_module_5() {
     // We group the calls together
     start_module_5(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -192,18 +178,15 @@ fn test_module_6() {
     // We group the calls together
     start_module_6(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -219,17 +202,14 @@ fn test_module_7() {
     // We group the calls together
     start_module_7(&mut instance);
 }
-fn create_module_8() -> Box<Instance> {
+fn create_module_8() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_8(instance: &mut Instance) {
@@ -245,17 +225,14 @@ fn test_module_8() {
     // We group the calls together
     start_module_8(&mut instance);
 }
-fn create_module_9() -> Box<Instance> {
+fn create_module_9() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_9(instance: &mut Instance) {
@@ -271,17 +248,14 @@ fn test_module_9() {
     // We group the calls together
     start_module_9(&mut instance);
 }
-fn create_module_10() -> Box<Instance> {
+fn create_module_10() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_10(instance: &mut Instance) {
@@ -297,17 +271,14 @@ fn test_module_10() {
     // We group the calls together
     start_module_10(&mut instance);
 }
-fn create_module_11() -> Box<Instance> {
+fn create_module_11() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_11(instance: &mut Instance) {
@@ -323,17 +294,14 @@ fn test_module_11() {
     // We group the calls together
     start_module_11(&mut instance);
 }
-fn create_module_12() -> Box<Instance> {
+fn create_module_12() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_12(instance: &mut Instance) {
@@ -349,17 +317,14 @@ fn test_module_12() {
     // We group the calls together
     start_module_12(&mut instance);
 }
-fn create_module_13() -> Box<Instance> {
+fn create_module_13() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_13(instance: &mut Instance) {
@@ -375,17 +340,14 @@ fn test_module_13() {
     // We group the calls together
     start_module_13(&mut instance);
 }
-fn create_module_14() -> Box<Instance> {
+fn create_module_14() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_14(instance: &mut Instance) {
@@ -401,17 +363,14 @@ fn test_module_14() {
     // We group the calls together
     start_module_14(&mut instance);
 }
-fn create_module_15() -> Box<Instance> {
+fn create_module_15() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_15(instance: &mut Instance) {
@@ -427,17 +386,14 @@ fn test_module_15() {
     // We group the calls together
     start_module_15(&mut instance);
 }
-fn create_module_16() -> Box<Instance> {
+fn create_module_16() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_16(instance: &mut Instance) {
@@ -453,17 +409,14 @@ fn test_module_16() {
     // We group the calls together
     start_module_16(&mut instance);
 }
-fn create_module_17() -> Box<Instance> {
+fn create_module_17() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_17(instance: &mut Instance) {
@@ -479,17 +432,14 @@ fn test_module_17() {
     // We group the calls together
     start_module_17(&mut instance);
 }
-fn create_module_18() -> Box<Instance> {
+fn create_module_18() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_18(instance: &mut Instance) {
@@ -505,17 +455,14 @@ fn test_module_18() {
     // We group the calls together
     start_module_18(&mut instance);
 }
-fn create_module_19() -> Box<Instance> {
+fn create_module_19() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_19(instance: &mut Instance) {
@@ -562,9 +509,7 @@ fn c33_l289_assert_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 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");
 }
@@ -572,9 +517,7 @@ fn c34_l298_assert_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 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");
 }
@@ -582,9 +525,7 @@ fn c35_l306_assert_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 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");
 }
@@ -592,9 +533,7 @@ fn c36_l314_assert_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 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");
 }
@@ -602,9 +541,7 @@ fn c37_l322_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/elem.rs b/lib/runtime/tests/spectests/elem.rs
index ac9236c97..8168961d0 100644
--- a/lib/runtime/tests/spectests/elem.rs
+++ b/lib/runtime/tests/spectests/elem.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 4
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0))
@@ -34,11 +38,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -54,7 +55,7 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0))
@@ -62,11 +63,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -82,7 +80,7 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"table\" (table (;0;) 10 anyfunc))
@@ -90,11 +88,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -110,7 +105,7 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0))
@@ -122,11 +117,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -142,7 +134,7 @@ fn test_module_4() {
     // We group the calls together
     start_module_4(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"table\" (table (;0;) 10 anyfunc))
@@ -154,11 +146,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -174,7 +163,7 @@ fn test_module_5() {
     // We group the calls together
     start_module_5(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"global_i32\" (global (;0;) i32))
@@ -183,11 +172,8 @@ fn create_module_6() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -203,7 +189,7 @@ fn test_module_6() {
     // We group the calls together
     start_module_6(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"global_i32\" (global (;0;) i32))
@@ -212,11 +198,8 @@ fn create_module_7() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -232,7 +215,7 @@ fn test_module_7() {
     // We group the calls together
     start_module_7(&mut instance);
 }
-fn create_module_8() -> Box<Instance> {
+fn create_module_8() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (func (;0;) (type 0) (result i32)
@@ -252,11 +235,8 @@ fn create_module_8() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_8(instance: &mut Instance) {
@@ -290,7 +270,7 @@ fn test_module_8() {
     c8_l81_action_invoke(&mut instance);
     c9_l82_action_invoke(&mut instance);
 }
-fn create_module_9() -> Box<Instance> {
+fn create_module_9() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0))
@@ -298,11 +278,8 @@ fn create_module_9() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_9(instance: &mut Instance) {
@@ -318,7 +295,7 @@ fn test_module_9() {
     // We group the calls together
     start_module_9(&mut instance);
 }
-fn create_module_10() -> Box<Instance> {
+fn create_module_10() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"table\" (table (;0;) 10 anyfunc))
@@ -326,11 +303,8 @@ fn create_module_10() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_10(instance: &mut Instance) {
@@ -346,17 +320,14 @@ fn test_module_10() {
     // We group the calls together
     start_module_10(&mut instance);
 }
-fn create_module_11() -> Box<Instance> {
+fn create_module_11() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_11(instance: &mut Instance) {
@@ -372,17 +343,14 @@ fn test_module_11() {
     // We group the calls together
     start_module_11(&mut instance);
 }
-fn create_module_12() -> Box<Instance> {
+fn create_module_12() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_12(instance: &mut Instance) {
@@ -398,17 +366,14 @@ fn test_module_12() {
     // We group the calls together
     start_module_12(&mut instance);
 }
-fn create_module_13() -> Box<Instance> {
+fn create_module_13() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_13(instance: &mut Instance) {
@@ -424,17 +389,14 @@ fn test_module_13() {
     // We group the calls together
     start_module_13(&mut instance);
 }
-fn create_module_14() -> Box<Instance> {
+fn create_module_14() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_14(instance: &mut Instance) {
@@ -450,7 +412,7 @@ fn test_module_14() {
     // We group the calls together
     start_module_14(&mut instance);
 }
-fn create_module_15() -> Box<Instance> {
+fn create_module_15() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"table\" (table (;0;) 0 anyfunc))
@@ -458,11 +420,8 @@ fn create_module_15() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_15(instance: &mut Instance) {
@@ -478,7 +437,7 @@ fn test_module_15() {
     // We group the calls together
     start_module_15(&mut instance);
 }
-fn create_module_16() -> Box<Instance> {
+fn create_module_16() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"table\" (table (;0;) 0 100 anyfunc))
@@ -486,11 +445,8 @@ fn create_module_16() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_16(instance: &mut Instance) {
@@ -506,7 +462,7 @@ fn test_module_16() {
     // We group the calls together
     start_module_16(&mut instance);
 }
-fn create_module_17() -> Box<Instance> {
+fn create_module_17() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"table\" (table (;0;) 0 anyfunc))
@@ -514,11 +470,8 @@ fn create_module_17() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_17(instance: &mut Instance) {
@@ -534,7 +487,7 @@ fn test_module_17() {
     // We group the calls together
     start_module_17(&mut instance);
 }
-fn create_module_18() -> Box<Instance> {
+fn create_module_18() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (import \"spectest\" \"table\" (table (;0;) 0 30 anyfunc))
@@ -542,11 +495,8 @@ fn create_module_18() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_18(instance: &mut Instance) {
@@ -581,10 +531,7 @@ fn start_module_18(instance: &mut Instance) {
 // 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 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");
 }
@@ -592,9 +539,7 @@ fn c32_l248_assert_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 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");
 }
@@ -602,9 +547,7 @@ fn c33_l258_assert_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 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");
 }
@@ -612,9 +555,7 @@ fn c34_l266_assert_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 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");
 }
@@ -622,9 +563,7 @@ fn c35_l274_assert_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 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");
 }
@@ -632,9 +571,7 @@ fn c36_l282_assert_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 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");
 }
@@ -647,7 +584,7 @@ fn test_module_18() {
     // We group the calls together
     start_module_18(&mut instance);
 }
-fn create_module_19() -> Box<Instance> {
+fn create_module_19() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (func (;0;) (type 0) (result i32)
@@ -663,11 +600,8 @@ fn create_module_19() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_19(instance: &mut Instance) {
@@ -692,7 +626,7 @@ fn test_module_19() {
     start_module_19(&mut instance);
     c39_l316_action_invoke(&mut instance);
 }
-fn create_module_20() -> Box<Instance> {
+fn create_module_20() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (import \"spectest\" \"table\" (table (;0;) 10 anyfunc))
@@ -708,11 +642,8 @@ fn create_module_20() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_20(instance: &mut Instance) {
@@ -737,7 +668,7 @@ fn test_module_20() {
     start_module_20(&mut instance);
     c41_l329_action_invoke(&mut instance);
 }
-fn create_module_21() -> Box<Instance> {
+fn create_module_21() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (func (;0;) (type 0) (result i32)
@@ -762,11 +693,8 @@ fn create_module_21() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_21(instance: &mut Instance) {
@@ -780,14 +708,14 @@ fn start_module_21(instance: &mut Instance) {
 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);
+    let result = c44_l353_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
diff --git a/lib/runtime/tests/spectests/endianness.rs b/lib/runtime/tests/spectests/endianness.rs
index 4deb926c8..2f335e5be 100644
--- a/lib/runtime/tests/spectests/endianness.rs
+++ b/lib/runtime/tests/spectests/endianness.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32)))
       (type (;1;) (func (param i32 i64)))
@@ -223,11 +227,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -518,16 +519,8 @@ fn c35_l175_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32_load", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -750,16 +743,8 @@ fn c63_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32_store", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
diff --git a/lib/runtime/tests/spectests/exports.rs b/lib/runtime/tests/spectests/exports.rs
index e1cbd1e1a..11e79078d 100644
--- a/lib/runtime/tests/spectests/exports.rs
+++ b/lib/runtime/tests/spectests/exports.rs
@@ -5,28 +5,29 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -42,7 +43,7 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0))
@@ -50,11 +51,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -70,7 +68,7 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0))
@@ -79,11 +77,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -99,18 +94,15 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -126,7 +118,7 @@ fn test_module_4() {
     // We group the calls together
     start_module_4(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (func (;0;) (type 0))
@@ -135,11 +127,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -155,7 +144,7 @@ fn test_module_5() {
     // We group the calls together
     start_module_5(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32)))
       (func (;0;) (type 0) (param i32))
@@ -163,11 +152,8 @@ fn create_module_6() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -183,18 +169,15 @@ fn test_module_6() {
     // We group the calls together
     start_module_6(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -210,18 +193,15 @@ fn test_module_7() {
     // We group the calls together
     start_module_7(&mut instance);
 }
-fn create_module_8() -> Box<Instance> {
+fn create_module_8() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_8(instance: &mut Instance) {
@@ -237,18 +217,15 @@ fn test_module_8() {
     // We group the calls together
     start_module_8(&mut instance);
 }
-fn create_module_9() -> Box<Instance> {
+fn create_module_9() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_9(instance: &mut Instance) {
@@ -264,18 +241,15 @@ fn test_module_9() {
     // We group the calls together
     start_module_9(&mut instance);
 }
-fn create_module_10() -> Box<Instance> {
+fn create_module_10() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_10(instance: &mut Instance) {
@@ -291,18 +265,15 @@ fn test_module_10() {
     // We group the calls together
     start_module_10(&mut instance);
 }
-fn create_module_11() -> Box<Instance> {
+fn create_module_11() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_11(instance: &mut Instance) {
@@ -318,7 +289,7 @@ fn test_module_11() {
     // We group the calls together
     start_module_11(&mut instance);
 }
-fn create_module_12() -> Box<Instance> {
+fn create_module_12() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (func (;0;) (type 0) (param i32) (result i32)
@@ -329,11 +300,8 @@ fn create_module_12() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_12(instance: &mut Instance) {
@@ -360,10 +328,7 @@ fn c13_l23_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -371,10 +336,7 @@ fn c14_l29_assert_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 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");
 }
@@ -382,10 +344,7 @@ fn c15_l33_assert_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 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");
 }
@@ -393,10 +352,7 @@ fn c16_l37_assert_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 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");
 }
@@ -404,10 +360,7 @@ fn c17_l41_assert_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 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");
 }
@@ -415,10 +368,7 @@ fn c18_l45_assert_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 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");
 }
@@ -433,17 +383,14 @@ fn test_module_12() {
     c12_l22_action_invoke(&mut instance);
     c13_l23_action_invoke(&mut instance);
 }
-fn create_module_13() -> Box<Instance> {
+fn create_module_13() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_13(instance: &mut Instance) {
@@ -459,18 +406,15 @@ fn test_module_13() {
     // We group the calls together
     start_module_13(&mut instance);
 }
-fn create_module_14() -> Box<Instance> {
+fn create_module_14() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_14(instance: &mut Instance) {
@@ -486,7 +430,7 @@ fn test_module_14() {
     // We group the calls together
     start_module_14(&mut instance);
 }
-fn create_module_15() -> Box<Instance> {
+fn create_module_15() -> Instance {
     let module_str = "(module
       (global (;0;) i32 (i32.const 0))
       (global (;1;) i32 (i32.const 0))
@@ -494,11 +438,8 @@ fn create_module_15() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_15(instance: &mut Instance) {
@@ -514,17 +455,14 @@ fn test_module_15() {
     // We group the calls together
     start_module_15(&mut instance);
 }
-fn create_module_16() -> Box<Instance> {
+fn create_module_16() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_16(instance: &mut Instance) {
@@ -540,17 +478,14 @@ fn test_module_16() {
     // We group the calls together
     start_module_16(&mut instance);
 }
-fn create_module_17() -> Box<Instance> {
+fn create_module_17() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_17(instance: &mut Instance) {
@@ -566,17 +501,14 @@ fn test_module_17() {
     // We group the calls together
     start_module_17(&mut instance);
 }
-fn create_module_18() -> Box<Instance> {
+fn create_module_18() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_18(instance: &mut Instance) {
@@ -592,17 +524,14 @@ fn test_module_18() {
     // We group the calls together
     start_module_18(&mut instance);
 }
-fn create_module_19() -> Box<Instance> {
+fn create_module_19() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_19(instance: &mut Instance) {
@@ -618,17 +547,14 @@ fn test_module_19() {
     // We group the calls together
     start_module_19(&mut instance);
 }
-fn create_module_20() -> Box<Instance> {
+fn create_module_20() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_20(instance: &mut Instance) {
@@ -644,17 +570,14 @@ fn test_module_20() {
     // We group the calls together
     start_module_20(&mut instance);
 }
-fn create_module_21() -> Box<Instance> {
+fn create_module_21() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_21(instance: &mut Instance) {
@@ -670,17 +593,14 @@ fn test_module_21() {
     // We group the calls together
     start_module_21(&mut instance);
 }
-fn create_module_22() -> Box<Instance> {
+fn create_module_22() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_22(instance: &mut Instance) {
@@ -695,9 +615,7 @@ fn start_module_22(instance: &mut Instance) {
 // 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 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");
 }
@@ -705,9 +623,7 @@ fn c32_l78_assert_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 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");
 }
@@ -715,10 +631,7 @@ fn c33_l82_assert_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 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");
 }
@@ -726,10 +639,7 @@ fn c34_l86_assert_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 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");
 }
@@ -737,10 +647,7 @@ fn c35_l90_assert_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 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");
 }
@@ -748,10 +655,7 @@ fn c36_l94_assert_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 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");
 }
@@ -764,17 +668,14 @@ fn test_module_22() {
     // We group the calls together
     start_module_22(&mut instance);
 }
-fn create_module_23() -> Box<Instance> {
+fn create_module_23() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_23(instance: &mut Instance) {
@@ -790,18 +691,15 @@ fn test_module_23() {
     // We group the calls together
     start_module_23(&mut instance);
 }
-fn create_module_24() -> Box<Instance> {
+fn create_module_24() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_24(instance: &mut Instance) {
@@ -817,17 +715,14 @@ fn test_module_24() {
     // We group the calls together
     start_module_24(&mut instance);
 }
-fn create_module_25() -> Box<Instance> {
+fn create_module_25() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_25(instance: &mut Instance) {
@@ -843,17 +738,14 @@ fn test_module_25() {
     // We group the calls together
     start_module_25(&mut instance);
 }
-fn create_module_26() -> Box<Instance> {
+fn create_module_26() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_26(instance: &mut Instance) {
@@ -869,17 +761,14 @@ fn test_module_26() {
     // We group the calls together
     start_module_26(&mut instance);
 }
-fn create_module_27() -> Box<Instance> {
+fn create_module_27() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_27(instance: &mut Instance) {
@@ -895,17 +784,14 @@ fn test_module_27() {
     // We group the calls together
     start_module_27(&mut instance);
 }
-fn create_module_28() -> Box<Instance> {
+fn create_module_28() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_28(instance: &mut Instance) {
@@ -921,17 +807,14 @@ fn test_module_28() {
     // We group the calls together
     start_module_28(&mut instance);
 }
-fn create_module_29() -> Box<Instance> {
+fn create_module_29() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_29(instance: &mut Instance) {
@@ -947,17 +830,14 @@ fn test_module_29() {
     // We group the calls together
     start_module_29(&mut instance);
 }
-fn create_module_30() -> Box<Instance> {
+fn create_module_30() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_30(instance: &mut Instance) {
@@ -973,17 +853,14 @@ fn test_module_30() {
     // We group the calls together
     start_module_30(&mut instance);
 }
-fn create_module_31() -> Box<Instance> {
+fn create_module_31() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_31(instance: &mut Instance) {
@@ -999,17 +876,14 @@ fn test_module_31() {
     // We group the calls together
     start_module_31(&mut instance);
 }
-fn create_module_32() -> Box<Instance> {
+fn create_module_32() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_32(instance: &mut Instance) {
@@ -1025,17 +899,14 @@ fn test_module_32() {
     // We group the calls together
     start_module_32(&mut instance);
 }
-fn create_module_33() -> Box<Instance> {
+fn create_module_33() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_33(instance: &mut Instance) {
@@ -1051,17 +922,14 @@ fn test_module_33() {
     // We group the calls together
     start_module_33(&mut instance);
 }
-fn create_module_34() -> Box<Instance> {
+fn create_module_34() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_34(instance: &mut Instance) {
@@ -1077,17 +945,14 @@ fn test_module_34() {
     // We group the calls together
     start_module_34(&mut instance);
 }
-fn create_module_35() -> Box<Instance> {
+fn create_module_35() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_35(instance: &mut Instance) {
@@ -1103,17 +968,14 @@ fn test_module_35() {
     // We group the calls together
     start_module_35(&mut instance);
 }
-fn create_module_36() -> Box<Instance> {
+fn create_module_36() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_36(instance: &mut Instance) {
@@ -1124,9 +986,7 @@ fn start_module_36(instance: &mut Instance) {
 // 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 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");
 }
@@ -1134,9 +994,7 @@ fn c52_l126_assert_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 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");
 }
@@ -1144,10 +1002,7 @@ fn c53_l130_assert_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 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");
 }
@@ -1155,10 +1010,7 @@ fn c54_l139_assert_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 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");
 }
@@ -1166,10 +1018,7 @@ fn c55_l143_assert_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 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");
 }
@@ -1182,17 +1031,14 @@ fn test_module_36() {
     // We group the calls together
     start_module_36(&mut instance);
 }
-fn create_module_37() -> Box<Instance> {
+fn create_module_37() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_37(instance: &mut Instance) {
@@ -1208,18 +1054,15 @@ fn test_module_37() {
     // We group the calls together
     start_module_37(&mut instance);
 }
-fn create_module_38() -> Box<Instance> {
+fn create_module_38() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_38(instance: &mut Instance) {
@@ -1235,17 +1078,14 @@ fn test_module_38() {
     // We group the calls together
     start_module_38(&mut instance);
 }
-fn create_module_39() -> Box<Instance> {
+fn create_module_39() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_39(instance: &mut Instance) {
@@ -1261,17 +1101,14 @@ fn test_module_39() {
     // We group the calls together
     start_module_39(&mut instance);
 }
-fn create_module_40() -> Box<Instance> {
+fn create_module_40() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_40(instance: &mut Instance) {
@@ -1287,17 +1124,14 @@ fn test_module_40() {
     // We group the calls together
     start_module_40(&mut instance);
 }
-fn create_module_41() -> Box<Instance> {
+fn create_module_41() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_41(instance: &mut Instance) {
@@ -1313,17 +1147,14 @@ fn test_module_41() {
     // We group the calls together
     start_module_41(&mut instance);
 }
-fn create_module_42() -> Box<Instance> {
+fn create_module_42() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_42(instance: &mut Instance) {
@@ -1339,17 +1170,14 @@ fn test_module_42() {
     // We group the calls together
     start_module_42(&mut instance);
 }
-fn create_module_43() -> Box<Instance> {
+fn create_module_43() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_43(instance: &mut Instance) {
@@ -1365,17 +1193,14 @@ fn test_module_43() {
     // We group the calls together
     start_module_43(&mut instance);
 }
-fn create_module_44() -> Box<Instance> {
+fn create_module_44() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_44(instance: &mut Instance) {
@@ -1391,17 +1216,14 @@ fn test_module_44() {
     // We group the calls together
     start_module_44(&mut instance);
 }
-fn create_module_45() -> Box<Instance> {
+fn create_module_45() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_45(instance: &mut Instance) {
@@ -1417,17 +1239,14 @@ fn test_module_45() {
     // We group the calls together
     start_module_45(&mut instance);
 }
-fn create_module_46() -> Box<Instance> {
+fn create_module_46() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_46(instance: &mut Instance) {
@@ -1443,17 +1262,14 @@ fn test_module_46() {
     // We group the calls together
     start_module_46(&mut instance);
 }
-fn create_module_47() -> Box<Instance> {
+fn create_module_47() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_47(instance: &mut Instance) {
@@ -1469,17 +1285,14 @@ fn test_module_47() {
     // We group the calls together
     start_module_47(&mut instance);
 }
-fn create_module_48() -> Box<Instance> {
+fn create_module_48() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_48(instance: &mut Instance) {
@@ -1495,17 +1308,14 @@ fn test_module_48() {
     // We group the calls together
     start_module_48(&mut instance);
 }
-fn create_module_49() -> Box<Instance> {
+fn create_module_49() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_49(instance: &mut Instance) {
@@ -1521,17 +1331,14 @@ fn test_module_49() {
     // We group the calls together
     start_module_49(&mut instance);
 }
-fn create_module_50() -> Box<Instance> {
+fn create_module_50() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_50(instance: &mut Instance) {
@@ -1542,9 +1349,7 @@ fn start_module_50(instance: &mut Instance) {
 // 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 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");
 }
@@ -1552,9 +1357,7 @@ fn c71_l175_assert_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 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");
 }
@@ -1562,10 +1365,7 @@ fn c72_l179_assert_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 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");
 }
@@ -1573,10 +1373,7 @@ fn c73_l188_assert_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 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");
 }
@@ -1584,10 +1381,7 @@ fn c74_l192_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/f32_.rs b/lib/runtime/tests/spectests/f32_.rs
index acc61084d..af7722d79 100644
--- a/lib/runtime/tests/spectests/f32_.rs
+++ b/lib/runtime/tests/spectests/f32_.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 5
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f32) (result f32)))
@@ -71,11 +75,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -118,152 +119,64 @@ fn c4_l22_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -366,86 +279,39 @@ fn c24_l42_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -461,10 +327,7 @@ fn c30_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -479,281 +342,136 @@ fn c32_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c33_l51_assert_return_canonical_nan");
+    println!("Executing function {}", "c33_l51_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c33_l51_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c34_l52_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c34_l52_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c34_l52_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c35_l53_assert_return_canonical_nan");
+    println!("Executing function {}", "c35_l53_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c35_l53_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c36_l54_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c36_l54_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c36_l54_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c37_l55_assert_return_canonical_nan");
+    println!("Executing function {}", "c37_l55_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c37_l55_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c38_l56_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c38_l56_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c38_l56_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c39_l57_assert_return_canonical_nan");
+    println!("Executing function {}", "c39_l57_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c39_l57_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c40_l58_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c40_l58_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c40_l58_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000003f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -761,13 +479,7 @@ fn c46_l64_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -775,108 +487,47 @@ fn c47_l65_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000003f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754945f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754945f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -884,13 +535,7 @@ fn c53_l71_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -898,13 +543,7 @@ fn c54_l72_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -912,13 +551,7 @@ fn c55_l73_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -926,13 +559,7 @@ fn c56_l74_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -940,13 +567,7 @@ fn c57_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -954,13 +575,7 @@ fn c58_l76_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -968,13 +583,7 @@ fn c59_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -982,13 +591,7 @@ fn c60_l78_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -996,13 +599,7 @@ fn c61_l79_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -1010,13 +607,7 @@ fn c62_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -1024,13 +615,7 @@ fn c63_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -1038,89 +623,39 @@ fn c64_l82_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -1128,13 +663,7 @@ fn c69_l87_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -1142,13 +671,7 @@ fn c70_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -1156,382 +679,175 @@ fn c71_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c73_l91_assert_return_canonical_nan");
+    println!("Executing function {}", "c73_l91_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c73_l91_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c74_l92_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c74_l92_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c74_l92_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c75_l93_assert_return_canonical_nan");
+    println!("Executing function {}", "c75_l93_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c75_l93_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c76_l94_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c76_l94_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c76_l94_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c77_l95_assert_return_canonical_nan");
+    println!("Executing function {}", "c77_l95_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c77_l95_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c78_l96_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c78_l96_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c78_l96_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c79_l97_assert_return_canonical_nan");
+    println!("Executing function {}", "c79_l97_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c79_l97_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c80_l98_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c80_l98_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c80_l98_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754945f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754945f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -1539,13 +855,7 @@ fn c90_l108_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -1553,32 +863,15 @@ fn c91_l109_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -1586,13 +879,7 @@ fn c93_l111_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -1600,13 +887,7 @@ fn c94_l112_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -1614,13 +895,7 @@ fn c95_l113_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -1628,13 +903,7 @@ fn c96_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -1642,13 +911,7 @@ fn c97_l115_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -1656,13 +919,7 @@ fn c98_l116_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -1670,13 +927,7 @@ fn c99_l117_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -1684,13 +935,7 @@ fn c100_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -1698,13 +943,7 @@ fn c101_l119_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -1712,13 +951,7 @@ fn c102_l120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -1726,13 +959,7 @@ fn c103_l121_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -1740,89 +967,39 @@ fn c104_l122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -1830,13 +1007,7 @@ fn c109_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -1844,13 +1015,7 @@ fn c110_l128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -1858,198 +1023,96 @@ fn c111_l129_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c113_l131_assert_return_canonical_nan");
+    println!("Executing function {}", "c113_l131_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c113_l131_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c114_l132_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c114_l132_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c114_l132_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c115_l133_assert_return_canonical_nan");
+    println!("Executing function {}", "c115_l133_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c115_l133_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c116_l134_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c116_l134_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c116_l134_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c117_l135_assert_return_canonical_nan");
+    println!("Executing function {}", "c117_l135_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c117_l135_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c118_l136_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c118_l136_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c118_l136_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c119_l137_assert_return_canonical_nan");
+    println!("Executing function {}", "c119_l137_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c119_l137_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c120_l138_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c120_l138_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c120_l138_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -2088,13 +1151,7 @@ fn c124_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2102,13 +1159,7 @@ fn c125_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2116,13 +1167,7 @@ fn c126_l144_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2130,13 +1175,7 @@ fn c127_l145_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2144,13 +1183,7 @@ fn c128_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2158,13 +1191,7 @@ fn c129_l147_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2172,13 +1199,7 @@ fn c130_l148_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2186,13 +1207,7 @@ fn c131_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2296,86 +1311,39 @@ fn c144_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2391,10 +1359,7 @@ fn c150_l168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2409,173 +1374,89 @@ fn c152_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c153_l171_assert_return_canonical_nan");
+    println!("Executing function {}", "c153_l171_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c153_l171_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c154_l172_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c154_l172_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c154_l172_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c155_l173_assert_return_canonical_nan");
+    println!("Executing function {}", "c155_l173_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c155_l173_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c156_l174_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c156_l174_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c156_l174_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c157_l175_assert_return_canonical_nan");
+    println!("Executing function {}", "c157_l175_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c157_l175_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c158_l176_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c158_l176_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c158_l176_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c159_l177_assert_return_canonical_nan");
+    println!("Executing function {}", "c159_l177_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c159_l177_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c160_l178_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c160_l178_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c160_l178_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -2614,13 +1495,7 @@ fn c164_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2628,13 +1503,7 @@ fn c165_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2642,13 +1511,7 @@ fn c166_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2656,13 +1519,7 @@ fn c167_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2670,13 +1527,7 @@ fn c168_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2684,13 +1535,7 @@ fn c169_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2698,13 +1543,7 @@ fn c170_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2712,13 +1551,7 @@ fn c171_l189_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2822,86 +1655,39 @@ fn c184_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2917,10 +1703,7 @@ fn c190_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2935,173 +1718,89 @@ fn c192_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c193_l211_assert_return_canonical_nan");
+    println!("Executing function {}", "c193_l211_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c193_l211_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c194_l212_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c194_l212_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c194_l212_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c195_l213_assert_return_canonical_nan");
+    println!("Executing function {}", "c195_l213_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c195_l213_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c196_l214_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c196_l214_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c196_l214_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c197_l215_assert_return_canonical_nan");
+    println!("Executing function {}", "c197_l215_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c197_l215_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c198_l216_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c198_l216_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c198_l216_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c199_l217_assert_return_canonical_nan");
+    println!("Executing function {}", "c199_l217_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c199_l217_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c200_l218_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c200_l218_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c200_l218_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -3140,13 +1839,7 @@ fn c204_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3154,13 +1847,7 @@ fn c205_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3168,13 +1855,7 @@ fn c206_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3182,13 +1863,7 @@ fn c207_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3196,13 +1871,7 @@ fn c208_l226_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3210,13 +1879,7 @@ fn c209_l227_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3224,13 +1887,7 @@ fn c210_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3238,13 +1895,7 @@ fn c211_l229_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3316,10 +1967,7 @@ fn c220_l238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-12.566371f32)))));
     result.map(|_| ())
 }
@@ -3327,10 +1975,7 @@ fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -3338,10 +1983,7 @@ fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -3349,10 +1991,7 @@ fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((12.566371f32)))));
     result.map(|_| ())
 }
@@ -3360,86 +1999,39 @@ fn c224_l242_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3447,10 +2039,7 @@ fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3458,10 +2047,7 @@ fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3469,664 +2055,295 @@ fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c233_l251_assert_return_canonical_nan");
+    println!("Executing function {}", "c233_l251_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c233_l251_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c234_l252_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c234_l252_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c234_l252_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c235_l253_assert_return_canonical_nan");
+    println!("Executing function {}", "c235_l253_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c235_l253_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c236_l254_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c236_l254_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c236_l254_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c237_l255_assert_return_canonical_nan");
+    println!("Executing function {}", "c237_l255_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c237_l255_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c238_l256_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c238_l256_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c238_l256_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c239_l257_assert_return_canonical_nan");
+    println!("Executing function {}", "c239_l257_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c239_l257_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c240_l258_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c240_l258_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c240_l258_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4134,13 +2351,7 @@ fn c265_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -4148,13 +2359,7 @@ fn c266_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -4162,13 +2367,7 @@ fn c267_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4176,13 +2375,7 @@ fn c268_l286_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4190,13 +2383,7 @@ fn c269_l287_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4204,13 +2391,7 @@ fn c270_l288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4218,208 +2399,103 @@ fn c271_l289_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c273_l291_assert_return_canonical_nan");
+    println!("Executing function {}", "c273_l291_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c273_l291_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c274_l292_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c274_l292_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c274_l292_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c275_l293_assert_return_canonical_nan");
+    println!("Executing function {}", "c275_l293_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c275_l293_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c276_l294_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c276_l294_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c276_l294_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c277_l295_assert_return_canonical_nan");
+    println!("Executing function {}", "c277_l295_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c277_l295_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c278_l296_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c278_l296_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c278_l296_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c279_l297_assert_return_canonical_nan");
+    println!("Executing function {}", "c279_l297_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c279_l297_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c280_l298_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c280_l298_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c280_l298_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4427,10 +2503,7 @@ fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.0f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4454,13 +2527,7 @@ fn c284_l302_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4468,13 +2535,7 @@ fn c285_l303_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4482,13 +2543,7 @@ fn c286_l304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4496,13 +2551,7 @@ fn c287_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4510,13 +2559,7 @@ fn c288_l306_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4524,13 +2567,7 @@ fn c289_l307_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4538,13 +2575,7 @@ fn c290_l308_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4552,13 +2583,7 @@ fn c291_l309_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4566,10 +2591,7 @@ fn c292_l310_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4577,10 +2599,7 @@ fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.5f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4604,10 +2623,7 @@ fn c296_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4615,10 +2631,7 @@ fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((1.0f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4642,10 +2655,7 @@ fn c300_l318_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4653,10 +2663,7 @@ fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4664,10 +2671,7 @@ fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4675,10 +2679,7 @@ fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4686,13 +2687,7 @@ fn c304_l322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4700,13 +2695,7 @@ fn c305_l323_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4714,13 +2703,7 @@ fn c306_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4728,13 +2711,7 @@ fn c307_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4742,2050 +2719,1006 @@ fn c308_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     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), Value::F32(f32::INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c310_l328_assert_return_canonical_nan");
+    println!("Executing function {}", "c310_l328_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c310_l328_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32(f32::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c311_l329_assert_return_canonical_nan");
+    println!("Executing function {}", "c311_l329_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c311_l329_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c313_l331_assert_return_canonical_nan");
+    println!("Executing function {}", "c313_l331_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c313_l331_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c314_l332_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c314_l332_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c314_l332_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c315_l333_assert_return_canonical_nan");
+    println!("Executing function {}", "c315_l333_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c315_l333_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c316_l334_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c316_l334_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c316_l334_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c317_l335_assert_return_canonical_nan");
+    println!("Executing function {}", "c317_l335_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c317_l335_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c318_l336_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c318_l336_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c318_l336_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c319_l337_assert_return_canonical_nan");
+    println!("Executing function {}", "c319_l337_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c319_l337_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c320_l338_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c320_l338_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c320_l338_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c321_l339_assert_return_canonical_nan");
+    println!("Executing function {}", "c321_l339_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c321_l339_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c322_l340_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c322_l340_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c322_l340_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c323_l341_assert_return_canonical_nan");
+    println!("Executing function {}", "c323_l341_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c323_l341_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c324_l342_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c324_l342_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c324_l342_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c325_l343_assert_return_canonical_nan");
+    println!("Executing function {}", "c325_l343_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c325_l343_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c326_l344_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c326_l344_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c326_l344_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c327_l345_assert_return_canonical_nan");
+    println!("Executing function {}", "c327_l345_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c327_l345_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c328_l346_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c328_l346_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c328_l346_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c329_l347_assert_return_canonical_nan");
+    println!("Executing function {}", "c329_l347_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c329_l347_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c330_l348_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c330_l348_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c330_l348_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c331_l349_assert_return_canonical_nan");
+    println!("Executing function {}", "c331_l349_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c331_l349_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c332_l350_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c332_l350_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c332_l350_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c333_l351_assert_return_canonical_nan");
+    println!("Executing function {}", "c333_l351_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c333_l351_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c334_l352_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c334_l352_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c334_l352_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c335_l353_assert_return_canonical_nan");
+    println!("Executing function {}", "c335_l353_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c335_l353_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c336_l354_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c336_l354_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c336_l354_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c337_l355_assert_return_canonical_nan");
+    println!("Executing function {}", "c337_l355_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c337_l355_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c338_l356_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c338_l356_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c338_l356_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c339_l357_assert_return_canonical_nan");
+    println!("Executing function {}", "c339_l357_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c339_l357_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c340_l358_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c340_l358_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c340_l358_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c341_l359_assert_return_canonical_nan");
+    println!("Executing function {}", "c341_l359_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c341_l359_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c342_l360_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c342_l360_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c342_l360_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c343_l361_assert_return_canonical_nan");
+    println!("Executing function {}", "c343_l361_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c343_l361_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c344_l362_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c344_l362_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c344_l362_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c345_l363_assert_return_canonical_nan");
+    println!("Executing function {}", "c345_l363_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c345_l363_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c346_l364_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c346_l364_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c346_l364_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c347_l365_assert_return_canonical_nan");
+    println!("Executing function {}", "c347_l365_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c347_l365_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c348_l366_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c348_l366_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c348_l366_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c349_l367_assert_return_canonical_nan");
+    println!("Executing function {}", "c349_l367_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c349_l367_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c350_l368_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c350_l368_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c350_l368_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c351_l369_assert_return_canonical_nan");
+    println!("Executing function {}", "c351_l369_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c351_l369_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c352_l370_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c352_l370_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c352_l370_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c353_l371_assert_return_canonical_nan");
+    println!("Executing function {}", "c353_l371_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c353_l371_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c354_l372_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c354_l372_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c354_l372_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c355_l373_assert_return_canonical_nan");
+    println!("Executing function {}", "c355_l373_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c355_l373_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c356_l374_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c356_l374_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c356_l374_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c357_l375_assert_return_canonical_nan");
+    println!("Executing function {}", "c357_l375_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c357_l375_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c358_l376_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c358_l376_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c358_l376_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c359_l377_assert_return_canonical_nan");
+    println!("Executing function {}", "c359_l377_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c359_l377_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c360_l378_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c360_l378_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c360_l378_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c361_l379_assert_return_canonical_nan");
+    println!("Executing function {}", "c361_l379_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c361_l379_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c362_l380_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c362_l380_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c362_l380_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c363_l381_assert_return_canonical_nan");
+    println!("Executing function {}", "c363_l381_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c363_l381_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c364_l382_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c364_l382_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c364_l382_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c365_l383_assert_return_canonical_nan");
+    println!("Executing function {}", "c365_l383_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c365_l383_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c366_l384_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c366_l384_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c366_l384_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c367_l385_assert_return_canonical_nan");
+    println!("Executing function {}", "c367_l385_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c367_l385_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c368_l386_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c368_l386_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c368_l386_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c369_l387_assert_return_canonical_nan");
+    println!("Executing function {}", "c369_l387_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c369_l387_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c370_l388_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c370_l388_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c370_l388_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c371_l389_assert_return_canonical_nan");
+    println!("Executing function {}", "c371_l389_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c371_l389_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c372_l390_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c372_l390_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c372_l390_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c373_l391_assert_return_canonical_nan");
+    println!("Executing function {}", "c373_l391_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c373_l391_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c374_l392_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c374_l392_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c374_l392_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c375_l393_assert_return_canonical_nan");
+    println!("Executing function {}", "c375_l393_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c375_l393_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c376_l394_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c376_l394_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c376_l394_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c377_l395_assert_return_canonical_nan");
+    println!("Executing function {}", "c377_l395_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c377_l395_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c378_l396_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c378_l396_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c378_l396_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c379_l397_assert_return_canonical_nan");
+    println!("Executing function {}", "c379_l397_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c379_l397_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c380_l398_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c380_l398_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c380_l398_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c381_l399_assert_return_canonical_nan");
+    println!("Executing function {}", "c381_l399_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c381_l399_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c382_l400_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c382_l400_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c382_l400_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c383_l401_assert_return_canonical_nan");
+    println!("Executing function {}", "c383_l401_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c383_l401_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c384_l402_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c384_l402_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c384_l402_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c385_l403_assert_return_canonical_nan");
+    println!("Executing function {}", "c385_l403_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c385_l403_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c386_l404_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c386_l404_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c386_l404_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c387_l405_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c387_l405_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c387_l405_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c388_l406_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c388_l406_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c388_l406_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c389_l407_assert_return_canonical_nan");
+    println!("Executing function {}", "c389_l407_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c389_l407_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c390_l408_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c390_l408_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c390_l408_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c391_l409_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c391_l409_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c391_l409_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c392_l410_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c392_l410_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c392_l410_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c393_l411_assert_return_canonical_nan");
+    println!("Executing function {}", "c393_l411_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c393_l411_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c394_l412_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c394_l412_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c394_l412_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c395_l413_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c395_l413_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c395_l413_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c396_l414_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c396_l414_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c396_l414_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c397_l415_assert_return_canonical_nan");
+    println!("Executing function {}", "c397_l415_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c397_l415_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c398_l416_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c398_l416_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c398_l416_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c399_l417_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c399_l417_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c399_l417_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c400_l418_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c400_l418_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c400_l418_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -6824,152 +3757,64 @@ fn c404_l422_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -7072,86 +3917,39 @@ fn c424_l442_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -7167,10 +3965,7 @@ fn c430_l448_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -7185,262 +3980,128 @@ fn c432_l450_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c433_l451_assert_return_canonical_nan");
+    println!("Executing function {}", "c433_l451_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c433_l451_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c434_l452_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c434_l452_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c434_l452_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c435_l453_assert_return_canonical_nan");
+    println!("Executing function {}", "c435_l453_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c435_l453_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c436_l454_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c436_l454_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c436_l454_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c437_l455_assert_return_canonical_nan");
+    println!("Executing function {}", "c437_l455_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c437_l455_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c438_l456_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c438_l456_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c438_l456_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c439_l457_assert_return_canonical_nan");
+    println!("Executing function {}", "c439_l457_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c439_l457_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c440_l458_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c440_l458_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c440_l458_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7448,51 +4109,23 @@ fn c445_l463_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000003f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000003f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7500,89 +4133,39 @@ fn c448_l466_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754945f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754945f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -7590,13 +4173,7 @@ fn c453_l471_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -7604,13 +4181,7 @@ fn c454_l472_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -7618,13 +4189,7 @@ fn c455_l473_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -7632,13 +4197,7 @@ fn c456_l474_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -7646,13 +4205,7 @@ fn c457_l475_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -7660,13 +4213,7 @@ fn c458_l476_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -7674,13 +4221,7 @@ fn c459_l477_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -7688,13 +4229,7 @@ fn c460_l478_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -7702,13 +4237,7 @@ fn c461_l479_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -7716,13 +4245,7 @@ fn c462_l480_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -7730,13 +4253,7 @@ fn c463_l481_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -7744,89 +4261,39 @@ fn c464_l482_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -7834,13 +4301,7 @@ fn c469_l487_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -7848,13 +4309,7 @@ fn c470_l488_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -7862,363 +4317,167 @@ fn c471_l489_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c473_l491_assert_return_canonical_nan");
+    println!("Executing function {}", "c473_l491_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c473_l491_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c474_l492_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c474_l492_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c474_l492_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c475_l493_assert_return_canonical_nan");
+    println!("Executing function {}", "c475_l493_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c475_l493_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c476_l494_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c476_l494_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c476_l494_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c477_l495_assert_return_canonical_nan");
+    println!("Executing function {}", "c477_l495_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c477_l495_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c478_l496_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c478_l496_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c478_l496_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c479_l497_assert_return_canonical_nan");
+    println!("Executing function {}", "c479_l497_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c479_l497_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c480_l498_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c480_l498_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c480_l498_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754945f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754945f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -8226,51 +4485,23 @@ fn c489_l507_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -8278,13 +4509,7 @@ fn c492_l510_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -8292,13 +4517,7 @@ fn c493_l511_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -8306,13 +4525,7 @@ fn c494_l512_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -8320,13 +4533,7 @@ fn c495_l513_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -8334,13 +4541,7 @@ fn c496_l514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -8348,13 +4549,7 @@ fn c497_l515_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -8362,13 +4557,7 @@ fn c498_l516_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -8376,13 +4565,7 @@ fn c499_l517_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -8390,13 +4573,7 @@ fn c500_l518_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -8404,13 +4581,7 @@ fn c501_l519_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -8418,13 +4589,7 @@ fn c502_l520_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -8432,13 +4597,7 @@ fn c503_l521_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -8446,89 +4605,39 @@ fn c504_l522_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -8536,13 +4645,7 @@ fn c509_l527_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8550,13 +4653,7 @@ fn c510_l528_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -8564,198 +4661,96 @@ fn c511_l529_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c513_l531_assert_return_canonical_nan");
+    println!("Executing function {}", "c513_l531_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c513_l531_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c514_l532_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c514_l532_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c514_l532_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c515_l533_assert_return_canonical_nan");
+    println!("Executing function {}", "c515_l533_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c515_l533_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c516_l534_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c516_l534_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c516_l534_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c517_l535_assert_return_canonical_nan");
+    println!("Executing function {}", "c517_l535_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c517_l535_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c518_l536_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c518_l536_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c518_l536_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c519_l537_assert_return_canonical_nan");
+    println!("Executing function {}", "c519_l537_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c519_l537_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c520_l538_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c520_l538_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c520_l538_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -8794,13 +4789,7 @@ fn c524_l542_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -8808,13 +4797,7 @@ fn c525_l543_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -8822,13 +4805,7 @@ fn c526_l544_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -8836,13 +4813,7 @@ fn c527_l545_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -8850,13 +4821,7 @@ fn c528_l546_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -8864,13 +4829,7 @@ fn c529_l547_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -8878,13 +4837,7 @@ fn c530_l548_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -8892,13 +4845,7 @@ fn c531_l549_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -9002,86 +4949,39 @@ fn c544_l562_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -9097,10 +4997,7 @@ fn c550_l568_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -9115,173 +5012,89 @@ fn c552_l570_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c553_l571_assert_return_canonical_nan");
+    println!("Executing function {}", "c553_l571_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c553_l571_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c554_l572_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c554_l572_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c554_l572_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c555_l573_assert_return_canonical_nan");
+    println!("Executing function {}", "c555_l573_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c555_l573_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c556_l574_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c556_l574_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c556_l574_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c557_l575_assert_return_canonical_nan");
+    println!("Executing function {}", "c557_l575_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c557_l575_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c558_l576_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c558_l576_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c558_l576_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c559_l577_assert_return_canonical_nan");
+    println!("Executing function {}", "c559_l577_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c559_l577_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c560_l578_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c560_l578_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c560_l578_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -9320,13 +5133,7 @@ fn c564_l582_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -9334,13 +5141,7 @@ fn c565_l583_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -9348,13 +5149,7 @@ fn c566_l584_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -9362,13 +5157,7 @@ fn c567_l585_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -9376,13 +5165,7 @@ fn c568_l586_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -9390,13 +5173,7 @@ fn c569_l587_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -9404,13 +5181,7 @@ fn c570_l588_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -9418,13 +5189,7 @@ fn c571_l589_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -9528,86 +5293,39 @@ fn c584_l602_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -9623,10 +5341,7 @@ fn c590_l608_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -9641,173 +5356,89 @@ fn c592_l610_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c593_l611_assert_return_canonical_nan");
+    println!("Executing function {}", "c593_l611_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c593_l611_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c594_l612_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c594_l612_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c594_l612_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c595_l613_assert_return_canonical_nan");
+    println!("Executing function {}", "c595_l613_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c595_l613_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c596_l614_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c596_l614_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c596_l614_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c597_l615_assert_return_canonical_nan");
+    println!("Executing function {}", "c597_l615_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c597_l615_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c598_l616_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c598_l616_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c598_l616_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c599_l617_assert_return_canonical_nan");
+    println!("Executing function {}", "c599_l617_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c599_l617_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c600_l618_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c600_l618_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c600_l618_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -9846,13 +5477,7 @@ fn c604_l622_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -9860,13 +5485,7 @@ fn c605_l623_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -9874,13 +5493,7 @@ fn c606_l624_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -9888,13 +5501,7 @@ fn c607_l625_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -9902,13 +5509,7 @@ fn c608_l626_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -9916,13 +5517,7 @@ fn c609_l627_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -9930,13 +5525,7 @@ fn c610_l628_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -9944,13 +5533,7 @@ fn c611_l629_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -10022,10 +5605,7 @@ fn c620_l638_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -10033,10 +5613,7 @@ fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-12.566371f32)))));
     result.map(|_| ())
 }
@@ -10044,10 +5621,7 @@ fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((12.566371f32)))));
     result.map(|_| ())
 }
@@ -10055,10 +5629,7 @@ fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -10066,86 +5637,39 @@ fn c624_l642_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -10153,10 +5677,7 @@ fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -10164,10 +5685,7 @@ fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -10175,664 +5693,295 @@ fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c633_l651_assert_return_canonical_nan");
+    println!("Executing function {}", "c633_l651_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c633_l651_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c634_l652_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c634_l652_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c634_l652_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c635_l653_assert_return_canonical_nan");
+    println!("Executing function {}", "c635_l653_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c635_l653_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c636_l654_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c636_l654_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c636_l654_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c637_l655_assert_return_canonical_nan");
+    println!("Executing function {}", "c637_l655_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c637_l655_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c638_l656_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c638_l656_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c638_l656_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c639_l657_assert_return_canonical_nan");
+    println!("Executing function {}", "c639_l657_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c639_l657_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c640_l658_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c640_l658_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c640_l658_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -10840,13 +5989,7 @@ fn c665_l683_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -10854,13 +5997,7 @@ fn c666_l684_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -10868,13 +6005,7 @@ fn c667_l685_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -10882,13 +6013,7 @@ fn c668_l686_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -10896,13 +6021,7 @@ fn c669_l687_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -10910,13 +6029,7 @@ fn c670_l688_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -10924,208 +6037,103 @@ fn c671_l689_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c673_l691_assert_return_canonical_nan");
+    println!("Executing function {}", "c673_l691_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c673_l691_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c674_l692_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c674_l692_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c674_l692_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c675_l693_assert_return_canonical_nan");
+    println!("Executing function {}", "c675_l693_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c675_l693_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c676_l694_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c676_l694_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c676_l694_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c677_l695_assert_return_canonical_nan");
+    println!("Executing function {}", "c677_l695_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c677_l695_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c678_l696_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c678_l696_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c678_l696_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c679_l697_assert_return_canonical_nan");
+    println!("Executing function {}", "c679_l697_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c679_l697_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c680_l698_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c680_l698_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c680_l698_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11133,10 +6141,7 @@ fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.0f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11160,13 +6165,7 @@ fn c684_l702_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11174,13 +6173,7 @@ fn c685_l703_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11188,13 +6181,7 @@ fn c686_l704_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -11202,13 +6189,7 @@ fn c687_l705_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -11216,13 +6197,7 @@ fn c688_l706_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11230,13 +6205,7 @@ fn c689_l707_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11244,13 +6213,7 @@ fn c690_l708_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -11258,13 +6221,7 @@ fn c691_l709_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -11272,10 +6229,7 @@ fn c692_l710_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11283,10 +6237,7 @@ fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.5f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11310,10 +6261,7 @@ fn c696_l714_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11321,10 +6269,7 @@ fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((1.0f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11348,10 +6293,7 @@ fn c700_l718_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11359,10 +6301,7 @@ fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11370,10 +6309,7 @@ fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -11381,10 +6317,7 @@ fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -11392,13 +6325,7 @@ fn c704_l722_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11406,13 +6333,7 @@ fn c705_l723_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11420,13 +6341,7 @@ fn c706_l724_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -11434,44 +6349,26 @@ fn c707_l725_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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), Value::F32(f32::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c709_l727_assert_return_canonical_nan");
+    println!("Executing function {}", "c709_l727_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c709_l727_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11479,2019 +6376,987 @@ fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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), Value::F32(f32::INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c712_l730_assert_return_canonical_nan");
+    println!("Executing function {}", "c712_l730_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c712_l730_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c713_l731_assert_return_canonical_nan");
+    println!("Executing function {}", "c713_l731_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c713_l731_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c714_l732_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c714_l732_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c714_l732_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c715_l733_assert_return_canonical_nan");
+    println!("Executing function {}", "c715_l733_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c715_l733_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c716_l734_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c716_l734_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c716_l734_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c717_l735_assert_return_canonical_nan");
+    println!("Executing function {}", "c717_l735_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c717_l735_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c718_l736_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c718_l736_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c718_l736_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c719_l737_assert_return_canonical_nan");
+    println!("Executing function {}", "c719_l737_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c719_l737_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c720_l738_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c720_l738_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c720_l738_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c721_l739_assert_return_canonical_nan");
+    println!("Executing function {}", "c721_l739_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c721_l739_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c722_l740_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c722_l740_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c722_l740_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c723_l741_assert_return_canonical_nan");
+    println!("Executing function {}", "c723_l741_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c723_l741_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c724_l742_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c724_l742_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c724_l742_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c725_l743_assert_return_canonical_nan");
+    println!("Executing function {}", "c725_l743_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c725_l743_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c726_l744_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c726_l744_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c726_l744_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c727_l745_assert_return_canonical_nan");
+    println!("Executing function {}", "c727_l745_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c727_l745_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c728_l746_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c728_l746_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c728_l746_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c729_l747_assert_return_canonical_nan");
+    println!("Executing function {}", "c729_l747_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c729_l747_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c730_l748_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c730_l748_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c730_l748_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c731_l749_assert_return_canonical_nan");
+    println!("Executing function {}", "c731_l749_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c731_l749_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c732_l750_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c732_l750_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c732_l750_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c733_l751_assert_return_canonical_nan");
+    println!("Executing function {}", "c733_l751_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c733_l751_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c734_l752_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c734_l752_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c734_l752_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c735_l753_assert_return_canonical_nan");
+    println!("Executing function {}", "c735_l753_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c735_l753_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c736_l754_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c736_l754_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c736_l754_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c737_l755_assert_return_canonical_nan");
+    println!("Executing function {}", "c737_l755_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c737_l755_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c738_l756_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c738_l756_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c738_l756_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c739_l757_assert_return_canonical_nan");
+    println!("Executing function {}", "c739_l757_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c739_l757_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c740_l758_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c740_l758_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c740_l758_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c741_l759_assert_return_canonical_nan");
+    println!("Executing function {}", "c741_l759_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c741_l759_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c742_l760_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c742_l760_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c742_l760_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c743_l761_assert_return_canonical_nan");
+    println!("Executing function {}", "c743_l761_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c743_l761_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c744_l762_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c744_l762_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c744_l762_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c745_l763_assert_return_canonical_nan");
+    println!("Executing function {}", "c745_l763_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c745_l763_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c746_l764_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c746_l764_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c746_l764_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c747_l765_assert_return_canonical_nan");
+    println!("Executing function {}", "c747_l765_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c747_l765_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c748_l766_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c748_l766_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c748_l766_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c749_l767_assert_return_canonical_nan");
+    println!("Executing function {}", "c749_l767_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c749_l767_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c750_l768_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c750_l768_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c750_l768_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c751_l769_assert_return_canonical_nan");
+    println!("Executing function {}", "c751_l769_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c751_l769_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c752_l770_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c752_l770_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c752_l770_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c753_l771_assert_return_canonical_nan");
+    println!("Executing function {}", "c753_l771_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c753_l771_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c754_l772_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c754_l772_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c754_l772_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c755_l773_assert_return_canonical_nan");
+    println!("Executing function {}", "c755_l773_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c755_l773_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c756_l774_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c756_l774_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c756_l774_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c757_l775_assert_return_canonical_nan");
+    println!("Executing function {}", "c757_l775_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c757_l775_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c758_l776_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c758_l776_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c758_l776_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c759_l777_assert_return_canonical_nan");
+    println!("Executing function {}", "c759_l777_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c759_l777_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c760_l778_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c760_l778_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c760_l778_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c761_l779_assert_return_canonical_nan");
+    println!("Executing function {}", "c761_l779_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c761_l779_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c762_l780_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c762_l780_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c762_l780_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c763_l781_assert_return_canonical_nan");
+    println!("Executing function {}", "c763_l781_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c763_l781_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c764_l782_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c764_l782_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c764_l782_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c765_l783_assert_return_canonical_nan");
+    println!("Executing function {}", "c765_l783_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c765_l783_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c766_l784_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c766_l784_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c766_l784_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c767_l785_assert_return_canonical_nan");
+    println!("Executing function {}", "c767_l785_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c767_l785_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c768_l786_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c768_l786_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c768_l786_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c769_l787_assert_return_canonical_nan");
+    println!("Executing function {}", "c769_l787_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c769_l787_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c770_l788_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c770_l788_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c770_l788_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c771_l789_assert_return_canonical_nan");
+    println!("Executing function {}", "c771_l789_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c771_l789_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c772_l790_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c772_l790_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c772_l790_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c773_l791_assert_return_canonical_nan");
+    println!("Executing function {}", "c773_l791_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c773_l791_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c774_l792_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c774_l792_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c774_l792_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c775_l793_assert_return_canonical_nan");
+    println!("Executing function {}", "c775_l793_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c775_l793_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c776_l794_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c776_l794_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c776_l794_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c777_l795_assert_return_canonical_nan");
+    println!("Executing function {}", "c777_l795_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c777_l795_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c778_l796_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c778_l796_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c778_l796_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c779_l797_assert_return_canonical_nan");
+    println!("Executing function {}", "c779_l797_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c779_l797_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c780_l798_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c780_l798_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c780_l798_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c781_l799_assert_return_canonical_nan");
+    println!("Executing function {}", "c781_l799_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c781_l799_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c782_l800_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c782_l800_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c782_l800_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c783_l801_assert_return_canonical_nan");
+    println!("Executing function {}", "c783_l801_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c783_l801_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c784_l802_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c784_l802_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c784_l802_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c785_l803_assert_return_canonical_nan");
+    println!("Executing function {}", "c785_l803_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c785_l803_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c786_l804_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c786_l804_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c786_l804_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c787_l805_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c787_l805_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c787_l805_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c788_l806_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c788_l806_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c788_l806_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c789_l807_assert_return_canonical_nan");
+    println!("Executing function {}", "c789_l807_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c789_l807_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c790_l808_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c790_l808_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c790_l808_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c791_l809_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c791_l809_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c791_l809_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c792_l810_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c792_l810_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c792_l810_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c793_l811_assert_return_canonical_nan");
+    println!("Executing function {}", "c793_l811_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c793_l811_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c794_l812_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c794_l812_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c794_l812_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c795_l813_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c795_l813_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c795_l813_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c796_l814_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c796_l814_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c796_l814_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c797_l815_assert_return_canonical_nan");
+    println!("Executing function {}", "c797_l815_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c797_l815_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c798_l816_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c798_l816_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c798_l816_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c799_l817_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c799_l817_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c799_l817_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c800_l818_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c800_l818_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c800_l818_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -13530,13 +7395,7 @@ fn c804_l822_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -13544,13 +7403,7 @@ fn c805_l823_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -13558,13 +7411,7 @@ fn c806_l824_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -13572,13 +7419,7 @@ fn c807_l825_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -13586,13 +7427,7 @@ fn c808_l826_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -13600,13 +7435,7 @@ fn c809_l827_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -13614,13 +7443,7 @@ fn c810_l828_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -13628,13 +7451,7 @@ fn c811_l829_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -13738,13 +7555,7 @@ fn c824_l842_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -13752,13 +7563,7 @@ fn c825_l843_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -13766,13 +7571,7 @@ fn c826_l844_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -13780,273 +7579,147 @@ fn c827_l845_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c829_l847_assert_return_canonical_nan");
+    println!("Executing function {}", "c829_l847_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c829_l847_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::INFINITY)])
-        .unwrap()
-        .expect("Missing result in c830_l848_assert_return_canonical_nan");
+    println!("Executing function {}", "c830_l848_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c830_l848_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c831_l849_assert_return_canonical_nan");
+    println!("Executing function {}", "c831_l849_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c831_l849_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::INFINITY)])
-        .unwrap()
-        .expect("Missing result in c832_l850_assert_return_canonical_nan");
+    println!("Executing function {}", "c832_l850_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c832_l850_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c833_l851_assert_return_canonical_nan");
+    println!("Executing function {}", "c833_l851_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c833_l851_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c834_l852_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c834_l852_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c834_l852_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c835_l853_assert_return_canonical_nan");
+    println!("Executing function {}", "c835_l853_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c835_l853_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c836_l854_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c836_l854_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c836_l854_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c837_l855_assert_return_canonical_nan");
+    println!("Executing function {}", "c837_l855_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c837_l855_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c838_l856_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c838_l856_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c838_l856_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c839_l857_assert_return_canonical_nan");
+    println!("Executing function {}", "c839_l857_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c839_l857_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c840_l858_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c840_l858_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c840_l858_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14054,13 +7727,7 @@ fn c841_l859_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14068,13 +7735,7 @@ fn c842_l860_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14082,13 +7743,7 @@ fn c843_l861_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14096,13 +7751,7 @@ fn c844_l862_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14110,13 +7759,7 @@ fn c845_l863_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14124,13 +7767,7 @@ fn c846_l864_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14138,13 +7775,7 @@ fn c847_l865_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14152,13 +7783,7 @@ fn c848_l866_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14166,13 +7791,7 @@ fn c849_l867_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14180,13 +7799,7 @@ fn c850_l868_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14194,13 +7807,7 @@ fn c851_l869_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14208,13 +7815,7 @@ fn c852_l870_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14222,13 +7823,7 @@ fn c853_l871_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14236,13 +7831,7 @@ fn c854_l872_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14250,13 +7839,7 @@ fn c855_l873_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14264,165 +7847,71 @@ fn c856_l874_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000008f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000008f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000008f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000008f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32)))));
     result.map(|_| ())
 }
@@ -14430,13 +7919,7 @@ fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32)))));
     result.map(|_| ())
 }
@@ -14444,13 +7927,7 @@ fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32)))));
     result.map(|_| ())
 }
@@ -14458,13 +7935,7 @@ fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32)))));
     result.map(|_| ())
 }
@@ -14472,13 +7943,7 @@ fn c868_l886_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -14486,13 +7951,7 @@ fn c869_l887_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -14500,13 +7959,7 @@ fn c870_l888_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -14514,211 +7967,103 @@ fn c871_l889_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c873_l891_assert_return_canonical_nan");
+    println!("Executing function {}", "c873_l891_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c873_l891_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c874_l892_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c874_l892_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c874_l892_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c875_l893_assert_return_canonical_nan");
+    println!("Executing function {}", "c875_l893_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c875_l893_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c876_l894_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c876_l894_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c876_l894_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c877_l895_assert_return_canonical_nan");
+    println!("Executing function {}", "c877_l895_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c877_l895_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c878_l896_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c878_l896_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c878_l896_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c879_l897_assert_return_canonical_nan");
+    println!("Executing function {}", "c879_l897_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c879_l897_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c880_l898_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c880_l898_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c880_l898_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14726,13 +8071,7 @@ fn c881_l899_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14740,13 +8079,7 @@ fn c882_l900_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14754,13 +8087,7 @@ fn c883_l901_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14768,13 +8095,7 @@ fn c884_l902_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14782,13 +8103,7 @@ fn c885_l903_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14796,13 +8111,7 @@ fn c886_l904_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14810,13 +8119,7 @@ fn c887_l905_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14824,13 +8127,7 @@ fn c888_l906_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14838,13 +8135,7 @@ fn c889_l907_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14852,13 +8143,7 @@ fn c890_l908_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -14866,13 +8151,7 @@ fn c891_l909_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -14880,241 +8159,103 @@ fn c892_l910_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000005877472f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000005877472f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000005877472f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000005877472f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.00000000000000000000000000000000000007385849f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.00000000000000000000000000000000000007385849f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.00000000000000000000000000000000000007385849f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.00000000000000000000000000000000000007385849f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((3.9999998f32)))));
     result.map(|_| ())
 }
@@ -15122,13 +8263,7 @@ fn c905_l923_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32)))));
     result.map(|_| ())
 }
@@ -15136,13 +8271,7 @@ fn c906_l924_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32)))));
     result.map(|_| ())
 }
@@ -15150,13 +8279,7 @@ fn c907_l925_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((3.9999998f32)))));
     result.map(|_| ())
 }
@@ -15164,13 +8287,7 @@ fn c908_l926_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -15178,13 +8295,7 @@ fn c909_l927_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -15192,13 +8303,7 @@ fn c910_l928_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -15206,198 +8311,96 @@ fn c911_l929_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c913_l931_assert_return_canonical_nan");
+    println!("Executing function {}", "c913_l931_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c913_l931_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c914_l932_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c914_l932_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c914_l932_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c915_l933_assert_return_canonical_nan");
+    println!("Executing function {}", "c915_l933_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c915_l933_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c916_l934_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c916_l934_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c916_l934_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c917_l935_assert_return_canonical_nan");
+    println!("Executing function {}", "c917_l935_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c917_l935_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c918_l936_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c918_l936_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c918_l936_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c919_l937_assert_return_canonical_nan");
+    println!("Executing function {}", "c919_l937_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c919_l937_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c920_l938_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c920_l938_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c920_l938_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -15436,13 +8439,7 @@ fn c924_l942_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -15450,13 +8447,7 @@ fn c925_l943_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -15464,13 +8455,7 @@ fn c926_l944_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -15478,13 +8463,7 @@ fn c927_l945_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -15492,76 +8471,32 @@ fn c928_l946_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000005877472f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000005877472f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000005877472f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000005877472f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32)))));
     result.map(|_| ())
 }
 
@@ -15664,86 +8599,39 @@ fn c944_l962_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (170141170000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-170141170000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-170141170000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (170141170000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -15759,10 +8647,7 @@ fn c950_l968_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -15777,173 +8662,89 @@ fn c952_l970_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c953_l971_assert_return_canonical_nan");
+    println!("Executing function {}", "c953_l971_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c953_l971_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c954_l972_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c954_l972_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c954_l972_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c955_l973_assert_return_canonical_nan");
+    println!("Executing function {}", "c955_l973_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c955_l973_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c956_l974_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c956_l974_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c956_l974_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c957_l975_assert_return_canonical_nan");
+    println!("Executing function {}", "c957_l975_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c957_l975_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c958_l976_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c958_l976_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c958_l976_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c959_l977_assert_return_canonical_nan");
+    println!("Executing function {}", "c959_l977_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c959_l977_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c960_l978_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c960_l978_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c960_l978_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -15982,152 +8783,64 @@ fn c964_l982_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -16230,86 +8943,39 @@ fn c984_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -16325,10 +8991,7 @@ fn c990_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -16343,173 +9006,89 @@ fn c992_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c993_l1011_assert_return_canonical_nan");
+    println!("Executing function {}", "c993_l1011_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c993_l1011_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c994_l1012_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c994_l1012_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c994_l1012_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c995_l1013_assert_return_canonical_nan");
+    println!("Executing function {}", "c995_l1013_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c995_l1013_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c996_l1014_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c996_l1014_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c996_l1014_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c997_l1015_assert_return_canonical_nan");
+    println!("Executing function {}", "c997_l1015_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c997_l1015_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c998_l1016_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c998_l1016_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c998_l1016_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c999_l1017_assert_return_canonical_nan");
+    println!("Executing function {}", "c999_l1017_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c999_l1017_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c1000_l1018_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1000_l1018_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1000_l1018_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -16548,152 +9127,64 @@ fn c1004_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000008f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000008f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000008f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000008f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.00000000000000000000000000000000000007385849f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.00000000000000000000000000000000000007385849f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.00000000000000000000000000000000000007385849f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.00000000000000000000000000000000000007385849f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32)))));
     result.map(|_| ())
 }
 
@@ -16764,10 +9255,7 @@ fn c1020_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((39.47842f32)))));
     result.map(|_| ())
 }
@@ -16775,10 +9263,7 @@ fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-39.47842f32)))));
     result.map(|_| ())
 }
@@ -16786,10 +9271,7 @@ fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-39.47842f32)))));
     result.map(|_| ())
 }
@@ -16797,10 +9279,7 @@ fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((39.47842f32)))));
     result.map(|_| ())
 }
@@ -16808,13 +9287,7 @@ fn c1024_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -16822,13 +9295,7 @@ fn c1025_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -16836,13 +9303,7 @@ fn c1026_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -16850,13 +9311,7 @@ fn c1027_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -16864,10 +9319,7 @@ fn c1028_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -16875,10 +9327,7 @@ fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -16886,10 +9335,7 @@ fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -16897,208 +9343,103 @@ fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1033_l1051_assert_return_canonical_nan");
+    println!("Executing function {}", "c1033_l1051_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1033_l1051_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1034_l1052_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1034_l1052_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1034_l1052_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1035_l1053_assert_return_canonical_nan");
+    println!("Executing function {}", "c1035_l1053_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1035_l1053_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1036_l1054_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1036_l1054_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1036_l1054_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1037_l1055_assert_return_canonical_nan");
+    println!("Executing function {}", "c1037_l1055_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1037_l1055_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1038_l1056_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1038_l1056_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1038_l1056_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1039_l1057_assert_return_canonical_nan");
+    println!("Executing function {}", "c1039_l1057_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1039_l1057_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1040_l1058_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1040_l1058_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1040_l1058_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -17106,13 +9447,7 @@ fn c1041_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -17120,13 +9455,7 @@ fn c1042_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -17134,13 +9463,7 @@ fn c1043_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -17148,13 +9471,7 @@ fn c1044_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32)))));
     result.map(|_| ())
 }
@@ -17162,13 +9479,7 @@ fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32)))));
     result.map(|_| ())
 }
@@ -17176,13 +9487,7 @@ fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32)))));
     result.map(|_| ())
 }
@@ -17190,13 +9495,7 @@ fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32)))));
     result.map(|_| ())
 }
@@ -17204,13 +9503,7 @@ fn c1048_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((3.9999998f32)))));
     result.map(|_| ())
 }
@@ -17218,13 +9511,7 @@ fn c1049_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32)))));
     result.map(|_| ())
 }
@@ -17232,13 +9519,7 @@ fn c1050_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32)))));
     result.map(|_| ())
 }
@@ -17246,13 +9527,7 @@ fn c1051_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((3.9999998f32)))));
     result.map(|_| ())
 }
@@ -17260,165 +9535,71 @@ fn c1052_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (170141170000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-170141170000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-170141170000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (170141170000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17426,13 +9607,7 @@ fn c1061_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17440,13 +9615,7 @@ fn c1062_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17454,13 +9623,7 @@ fn c1063_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17468,13 +9631,7 @@ fn c1064_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17482,13 +9639,7 @@ fn c1065_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17496,13 +9647,7 @@ fn c1066_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17510,13 +9655,7 @@ fn c1067_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17524,13 +9663,7 @@ fn c1068_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17538,13 +9671,7 @@ fn c1069_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17552,13 +9679,7 @@ fn c1070_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17566,285 +9687,147 @@ fn c1071_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1073_l1091_assert_return_canonical_nan");
+    println!("Executing function {}", "c1073_l1091_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1073_l1091_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1074_l1092_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1074_l1092_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1074_l1092_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1075_l1093_assert_return_canonical_nan");
+    println!("Executing function {}", "c1075_l1093_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1075_l1093_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1076_l1094_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1076_l1094_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1076_l1094_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1077_l1095_assert_return_canonical_nan");
+    println!("Executing function {}", "c1077_l1095_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1077_l1095_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1078_l1096_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1078_l1096_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1078_l1096_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1079_l1097_assert_return_canonical_nan");
+    println!("Executing function {}", "c1079_l1097_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1079_l1097_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1080_l1098_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1080_l1098_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1080_l1098_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((-0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1081_l1099_assert_return_canonical_nan");
+    println!("Executing function {}", "c1081_l1099_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1081_l1099_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1082_l1100_assert_return_canonical_nan");
+    println!("Executing function {}", "c1082_l1100_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1082_l1100_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((-0.0f32))])
-        .unwrap()
-        .expect("Missing result in c1083_l1101_assert_return_canonical_nan");
+    println!("Executing function {}", "c1083_l1101_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1083_l1101_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((0.0f32))])
-        .unwrap()
-        .expect("Missing result in c1084_l1102_assert_return_canonical_nan");
+    println!("Executing function {}", "c1084_l1102_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1084_l1102_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17852,13 +9835,7 @@ fn c1085_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17866,13 +9843,7 @@ fn c1086_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17880,13 +9851,7 @@ fn c1087_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17894,13 +9859,7 @@ fn c1088_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17908,13 +9867,7 @@ fn c1089_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17922,13 +9875,7 @@ fn c1090_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17936,13 +9883,7 @@ fn c1091_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17950,10 +9891,7 @@ fn c1092_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17961,10 +9899,7 @@ fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.5f32))],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17988,10 +9923,7 @@ fn c1096_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -17999,10 +9931,7 @@ fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((1.0f32))],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18026,10 +9955,7 @@ fn c1100_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -18037,10 +9963,7 @@ fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18048,10 +9971,7 @@ fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18059,10 +9979,7 @@ fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -18070,13 +9987,7 @@ fn c1104_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -18084,13 +9995,7 @@ fn c1105_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18098,13 +10003,7 @@ fn c1106_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18112,13 +10011,7 @@ fn c1107_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -18126,10 +10019,7 @@ fn c1108_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -18137,10 +10027,7 @@ fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18148,10 +10035,7 @@ fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18159,2080 +10043,1027 @@ fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1113_l1131_assert_return_canonical_nan");
+    println!("Executing function {}", "c1113_l1131_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1113_l1131_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1114_l1132_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1114_l1132_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1114_l1132_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1115_l1133_assert_return_canonical_nan");
+    println!("Executing function {}", "c1115_l1133_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1115_l1133_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1116_l1134_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1116_l1134_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1116_l1134_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1117_l1135_assert_return_canonical_nan");
+    println!("Executing function {}", "c1117_l1135_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1117_l1135_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1118_l1136_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1118_l1136_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1118_l1136_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1119_l1137_assert_return_canonical_nan");
+    println!("Executing function {}", "c1119_l1137_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1119_l1137_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1120_l1138_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1120_l1138_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1120_l1138_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1121_l1139_assert_return_canonical_nan");
+    println!("Executing function {}", "c1121_l1139_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1121_l1139_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1122_l1140_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1122_l1140_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1122_l1140_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1123_l1141_assert_return_canonical_nan");
+    println!("Executing function {}", "c1123_l1141_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1123_l1141_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1124_l1142_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1124_l1142_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1124_l1142_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1125_l1143_assert_return_canonical_nan");
+    println!("Executing function {}", "c1125_l1143_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1125_l1143_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1126_l1144_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1126_l1144_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1126_l1144_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1127_l1145_assert_return_canonical_nan");
+    println!("Executing function {}", "c1127_l1145_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1127_l1145_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1128_l1146_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1128_l1146_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1128_l1146_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1129_l1147_assert_return_canonical_nan");
+    println!("Executing function {}", "c1129_l1147_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1129_l1147_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1130_l1148_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1130_l1148_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1130_l1148_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1131_l1149_assert_return_canonical_nan");
+    println!("Executing function {}", "c1131_l1149_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1131_l1149_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1132_l1150_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1132_l1150_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1132_l1150_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1133_l1151_assert_return_canonical_nan");
+    println!("Executing function {}", "c1133_l1151_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1133_l1151_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1134_l1152_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1134_l1152_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1134_l1152_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1135_l1153_assert_return_canonical_nan");
+    println!("Executing function {}", "c1135_l1153_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1135_l1153_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1136_l1154_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1136_l1154_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1136_l1154_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1137_l1155_assert_return_canonical_nan");
+    println!("Executing function {}", "c1137_l1155_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1137_l1155_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1138_l1156_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1138_l1156_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1138_l1156_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1139_l1157_assert_return_canonical_nan");
+    println!("Executing function {}", "c1139_l1157_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1139_l1157_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1140_l1158_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1140_l1158_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1140_l1158_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1141_l1159_assert_return_canonical_nan");
+    println!("Executing function {}", "c1141_l1159_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1141_l1159_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1142_l1160_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1142_l1160_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1142_l1160_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1143_l1161_assert_return_canonical_nan");
+    println!("Executing function {}", "c1143_l1161_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1143_l1161_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1144_l1162_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1144_l1162_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1144_l1162_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1145_l1163_assert_return_canonical_nan");
+    println!("Executing function {}", "c1145_l1163_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1145_l1163_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1146_l1164_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1146_l1164_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1146_l1164_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1147_l1165_assert_return_canonical_nan");
+    println!("Executing function {}", "c1147_l1165_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1147_l1165_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1148_l1166_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1148_l1166_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1148_l1166_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1149_l1167_assert_return_canonical_nan");
+    println!("Executing function {}", "c1149_l1167_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1149_l1167_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1150_l1168_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1150_l1168_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1150_l1168_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1151_l1169_assert_return_canonical_nan");
+    println!("Executing function {}", "c1151_l1169_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1151_l1169_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1152_l1170_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1152_l1170_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1152_l1170_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1153_l1171_assert_return_canonical_nan");
+    println!("Executing function {}", "c1153_l1171_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1153_l1171_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1154_l1172_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1154_l1172_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1154_l1172_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1155_l1173_assert_return_canonical_nan");
+    println!("Executing function {}", "c1155_l1173_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1155_l1173_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1156_l1174_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1156_l1174_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1156_l1174_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1157_l1175_assert_return_canonical_nan");
+    println!("Executing function {}", "c1157_l1175_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1157_l1175_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1158_l1176_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1158_l1176_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1158_l1176_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1159_l1177_assert_return_canonical_nan");
+    println!("Executing function {}", "c1159_l1177_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1159_l1177_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1160_l1178_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1160_l1178_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1160_l1178_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1161_l1179_assert_return_canonical_nan");
+    println!("Executing function {}", "c1161_l1179_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1161_l1179_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1162_l1180_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1162_l1180_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1162_l1180_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1163_l1181_assert_return_canonical_nan");
+    println!("Executing function {}", "c1163_l1181_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1163_l1181_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1164_l1182_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1164_l1182_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1164_l1182_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1165_l1183_assert_return_canonical_nan");
+    println!("Executing function {}", "c1165_l1183_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1165_l1183_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1166_l1184_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1166_l1184_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1166_l1184_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1167_l1185_assert_return_canonical_nan");
+    println!("Executing function {}", "c1167_l1185_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1167_l1185_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1168_l1186_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1168_l1186_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1168_l1186_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1169_l1187_assert_return_canonical_nan");
+    println!("Executing function {}", "c1169_l1187_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1169_l1187_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1170_l1188_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1170_l1188_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1170_l1188_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1171_l1189_assert_return_canonical_nan");
+    println!("Executing function {}", "c1171_l1189_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1171_l1189_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1172_l1190_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1172_l1190_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1172_l1190_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1173_l1191_assert_return_canonical_nan");
+    println!("Executing function {}", "c1173_l1191_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1173_l1191_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1174_l1192_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1174_l1192_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1174_l1192_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1175_l1193_assert_return_canonical_nan");
+    println!("Executing function {}", "c1175_l1193_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1175_l1193_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1176_l1194_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1176_l1194_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1176_l1194_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1177_l1195_assert_return_canonical_nan");
+    println!("Executing function {}", "c1177_l1195_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1177_l1195_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1178_l1196_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1178_l1196_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1178_l1196_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1179_l1197_assert_return_canonical_nan");
+    println!("Executing function {}", "c1179_l1197_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1179_l1197_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1180_l1198_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1180_l1198_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1180_l1198_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1181_l1199_assert_return_canonical_nan");
+    println!("Executing function {}", "c1181_l1199_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1181_l1199_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1182_l1200_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1182_l1200_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1182_l1200_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1183_l1201_assert_return_canonical_nan");
+    println!("Executing function {}", "c1183_l1201_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1183_l1201_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1184_l1202_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1184_l1202_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1184_l1202_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1185_l1203_assert_return_canonical_nan");
+    println!("Executing function {}", "c1185_l1203_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1185_l1203_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1186_l1204_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1186_l1204_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1186_l1204_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1187_l1205_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1187_l1205_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1187_l1205_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1188_l1206_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1188_l1206_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1188_l1206_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1189_l1207_assert_return_canonical_nan");
+    println!("Executing function {}", "c1189_l1207_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1189_l1207_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1190_l1208_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1190_l1208_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1190_l1208_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1191_l1209_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1191_l1209_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1191_l1209_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1192_l1210_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1192_l1210_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1192_l1210_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1193_l1211_assert_return_canonical_nan");
+    println!("Executing function {}", "c1193_l1211_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1193_l1211_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1194_l1212_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1194_l1212_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1194_l1212_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1195_l1213_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1195_l1213_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1195_l1213_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1196_l1214_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1196_l1214_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1196_l1214_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1197_l1215_assert_return_canonical_nan");
+    println!("Executing function {}", "c1197_l1215_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1197_l1215_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1198_l1216_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1198_l1216_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1198_l1216_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1199_l1217_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1199_l1217_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1199_l1217_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1200_l1218_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1200_l1218_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1200_l1218_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((-0.0f32))])
-        .unwrap()
-        .expect("Missing result in c1201_l1219_assert_return_canonical_nan");
+    println!("Executing function {}", "c1201_l1219_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1201_l1219_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))])
-        .unwrap()
-        .expect("Missing result in c1202_l1220_assert_return_canonical_nan");
+    println!("Executing function {}", "c1202_l1220_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1202_l1220_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((-0.0f32))])
-        .unwrap()
-        .expect("Missing result in c1203_l1221_assert_return_canonical_nan");
+    println!("Executing function {}", "c1203_l1221_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1203_l1221_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))])
-        .unwrap()
-        .expect("Missing result in c1204_l1222_assert_return_canonical_nan");
+    println!("Executing function {}", "c1204_l1222_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1204_l1222_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -20240,13 +11071,7 @@ fn c1205_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -20254,13 +11079,7 @@ fn c1206_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -20268,13 +11087,7 @@ fn c1207_l1225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -20282,13 +11095,7 @@ fn c1208_l1226_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -20296,13 +11103,7 @@ fn c1209_l1227_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -20310,13 +11111,7 @@ fn c1210_l1228_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -20324,13 +11119,7 @@ fn c1211_l1229_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -20434,13 +11223,7 @@ fn c1224_l1242_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -20448,13 +11231,7 @@ fn c1225_l1243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -20462,13 +11239,7 @@ fn c1226_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -20476,13 +11247,7 @@ fn c1227_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -20490,10 +11255,7 @@ fn c1228_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -20509,10 +11271,7 @@ fn c1230_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -20527,186 +11286,96 @@ fn c1232_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1233_l1251_assert_return_canonical_nan");
+    println!("Executing function {}", "c1233_l1251_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1233_l1251_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1234_l1252_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1234_l1252_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1234_l1252_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1235_l1253_assert_return_canonical_nan");
+    println!("Executing function {}", "c1235_l1253_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1235_l1253_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1236_l1254_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1236_l1254_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1236_l1254_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c1237_l1255_assert_return_canonical_nan");
+    println!("Executing function {}", "c1237_l1255_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1237_l1255_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c1238_l1256_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1238_l1256_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1238_l1256_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c1239_l1257_assert_return_canonical_nan");
+    println!("Executing function {}", "c1239_l1257_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1239_l1257_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c1240_l1258_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1240_l1258_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1240_l1258_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -20714,13 +11383,7 @@ fn c1241_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -20728,13 +11391,7 @@ fn c1242_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -20742,13 +11399,7 @@ fn c1243_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -20756,13 +11407,7 @@ fn c1244_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -20770,13 +11415,7 @@ fn c1245_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -20784,13 +11423,7 @@ fn c1246_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -20798,13 +11431,7 @@ fn c1247_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -20812,13 +11439,7 @@ fn c1248_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32)))));
     result.map(|_| ())
 }
@@ -20826,13 +11447,7 @@ fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32)))));
     result.map(|_| ())
 }
@@ -20840,13 +11455,7 @@ fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32)))));
     result.map(|_| ())
 }
@@ -20854,13 +11463,7 @@ fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32)))));
     result.map(|_| ())
 }
@@ -20868,165 +11471,71 @@ fn c1252_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000003f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000003f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000003f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000003f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -21034,13 +11543,7 @@ fn c1261_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21048,13 +11551,7 @@ fn c1262_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21062,13 +11559,7 @@ fn c1263_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -21076,13 +11567,7 @@ fn c1264_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -21090,13 +11575,7 @@ fn c1265_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21104,13 +11583,7 @@ fn c1266_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21118,13 +11591,7 @@ fn c1267_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -21132,13 +11599,7 @@ fn c1268_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -21146,13 +11607,7 @@ fn c1269_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21160,13 +11615,7 @@ fn c1270_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21174,211 +11623,103 @@ fn c1271_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1273_l1291_assert_return_canonical_nan");
+    println!("Executing function {}", "c1273_l1291_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1273_l1291_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1274_l1292_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1274_l1292_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1274_l1292_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1275_l1293_assert_return_canonical_nan");
+    println!("Executing function {}", "c1275_l1293_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1275_l1293_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1276_l1294_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1276_l1294_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1276_l1294_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1277_l1295_assert_return_canonical_nan");
+    println!("Executing function {}", "c1277_l1295_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1277_l1295_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1278_l1296_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1278_l1296_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1278_l1296_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1279_l1297_assert_return_canonical_nan");
+    println!("Executing function {}", "c1279_l1297_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1279_l1297_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1280_l1298_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1280_l1298_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1280_l1298_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -21386,13 +11727,7 @@ fn c1281_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -21400,13 +11735,7 @@ fn c1282_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -21414,13 +11743,7 @@ fn c1283_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -21428,13 +11751,7 @@ fn c1284_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((8388608.0f32)))));
     result.map(|_| ())
 }
@@ -21442,13 +11759,7 @@ fn c1285_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32)))));
     result.map(|_| ())
 }
@@ -21456,13 +11767,7 @@ fn c1286_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32)))));
     result.map(|_| ())
 }
@@ -21470,13 +11775,7 @@ fn c1287_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((8388608.0f32)))));
     result.map(|_| ())
 }
@@ -21484,13 +11783,7 @@ fn c1288_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -21498,13 +11791,7 @@ fn c1289_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -21512,13 +11799,7 @@ fn c1290_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -21526,13 +11807,7 @@ fn c1291_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -21540,241 +11815,103 @@ fn c1292_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000001870857f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001870857f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000001870857f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001870857f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000001870857f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001870857f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000001870857f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001870857f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -21782,13 +11919,7 @@ fn c1305_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21796,13 +11927,7 @@ fn c1306_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21810,13 +11935,7 @@ fn c1307_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -21824,13 +11943,7 @@ fn c1308_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -21838,13 +11951,7 @@ fn c1309_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21852,13 +11959,7 @@ fn c1310_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -21866,198 +11967,96 @@ fn c1311_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1313_l1331_assert_return_canonical_nan");
+    println!("Executing function {}", "c1313_l1331_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1313_l1331_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1314_l1332_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1314_l1332_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1314_l1332_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1315_l1333_assert_return_canonical_nan");
+    println!("Executing function {}", "c1315_l1333_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1315_l1333_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1316_l1334_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1316_l1334_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1316_l1334_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1317_l1335_assert_return_canonical_nan");
+    println!("Executing function {}", "c1317_l1335_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1317_l1335_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1318_l1336_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1318_l1336_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1318_l1336_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1319_l1337_assert_return_canonical_nan");
+    println!("Executing function {}", "c1319_l1337_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1319_l1337_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1320_l1338_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1320_l1338_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1320_l1338_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -22096,13 +12095,7 @@ fn c1324_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -22110,13 +12103,7 @@ fn c1325_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -22124,13 +12111,7 @@ fn c1326_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -22138,13 +12119,7 @@ fn c1327_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -22152,76 +12127,32 @@ fn c1328_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (42535296000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((42535296000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-42535296000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-42535296000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-42535296000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-42535296000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (42535296000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((42535296000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -22324,86 +12255,39 @@ fn c1344_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000001469368f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001469368f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000001469368f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001469368f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000001469368f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001469368f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000001469368f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001469368f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -22419,10 +12303,7 @@ fn c1350_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -22437,173 +12318,89 @@ fn c1352_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1353_l1371_assert_return_canonical_nan");
+    println!("Executing function {}", "c1353_l1371_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1353_l1371_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1354_l1372_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1354_l1372_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1354_l1372_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1355_l1373_assert_return_canonical_nan");
+    println!("Executing function {}", "c1355_l1373_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1355_l1373_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1356_l1374_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1356_l1374_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1356_l1374_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c1357_l1375_assert_return_canonical_nan");
+    println!("Executing function {}", "c1357_l1375_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1357_l1375_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c1358_l1376_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1358_l1376_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1358_l1376_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c1359_l1377_assert_return_canonical_nan");
+    println!("Executing function {}", "c1359_l1377_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1359_l1377_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c1360_l1378_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1360_l1378_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1360_l1378_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -22642,13 +12439,7 @@ fn c1364_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -22656,13 +12447,7 @@ fn c1365_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -22670,13 +12455,7 @@ fn c1366_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -22684,13 +12463,7 @@ fn c1367_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -22698,76 +12471,32 @@ fn c1368_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (85070590000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((85070590000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-85070590000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-85070590000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-85070590000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-85070590000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (85070590000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((85070590000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -22870,86 +12599,39 @@ fn c1384_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000002938736f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000002938736f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000002938736f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000002938736f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000002938736f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000002938736f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000002938736f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000002938736f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -22965,10 +12647,7 @@ fn c1390_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -22983,173 +12662,89 @@ fn c1392_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1393_l1411_assert_return_canonical_nan");
+    println!("Executing function {}", "c1393_l1411_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1393_l1411_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1394_l1412_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1394_l1412_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1394_l1412_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1395_l1413_assert_return_canonical_nan");
+    println!("Executing function {}", "c1395_l1413_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1395_l1413_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1396_l1414_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1396_l1414_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1396_l1414_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c1397_l1415_assert_return_canonical_nan");
+    println!("Executing function {}", "c1397_l1415_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1397_l1415_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c1398_l1416_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1398_l1416_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1398_l1416_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c1399_l1417_assert_return_canonical_nan");
+    println!("Executing function {}", "c1399_l1417_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1399_l1417_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c1400_l1418_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1400_l1418_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1400_l1418_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -23188,13 +12783,7 @@ fn c1404_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23202,13 +12791,7 @@ fn c1405_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23216,13 +12799,7 @@ fn c1406_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23230,13 +12807,7 @@ fn c1407_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23244,13 +12815,7 @@ fn c1408_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23258,13 +12823,7 @@ fn c1409_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23272,13 +12831,7 @@ fn c1410_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23286,13 +12839,7 @@ fn c1411_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23364,10 +12911,7 @@ fn c1420_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -23375,10 +12919,7 @@ fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -23386,10 +12927,7 @@ fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -23397,10 +12935,7 @@ fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -23408,86 +12943,39 @@ fn c1424_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000018464624f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000018464624f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000018464624f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000018464624f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000018464624f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000018464624f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000018464624f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000018464624f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -23495,10 +12983,7 @@ fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -23506,10 +12991,7 @@ fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -23517,208 +12999,103 @@ fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1433_l1451_assert_return_canonical_nan");
+    println!("Executing function {}", "c1433_l1451_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1433_l1451_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1434_l1452_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1434_l1452_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1434_l1452_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1435_l1453_assert_return_canonical_nan");
+    println!("Executing function {}", "c1435_l1453_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1435_l1453_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1436_l1454_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1436_l1454_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1436_l1454_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1437_l1455_assert_return_canonical_nan");
+    println!("Executing function {}", "c1437_l1455_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1437_l1455_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1438_l1456_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1438_l1456_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1438_l1456_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1439_l1457_assert_return_canonical_nan");
+    println!("Executing function {}", "c1439_l1457_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1439_l1457_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1440_l1458_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1440_l1458_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1440_l1458_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23726,13 +13103,7 @@ fn c1441_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23740,13 +13111,7 @@ fn c1442_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23754,13 +13119,7 @@ fn c1443_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23768,13 +13127,7 @@ fn c1444_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23782,13 +13135,7 @@ fn c1445_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23796,13 +13143,7 @@ fn c1446_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23810,13 +13151,7 @@ fn c1447_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23824,13 +13159,7 @@ fn c1448_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23838,13 +13167,7 @@ fn c1449_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23852,13 +13175,7 @@ fn c1450_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23866,13 +13183,7 @@ fn c1451_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23880,13 +13191,7 @@ fn c1452_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23894,13 +13199,7 @@ fn c1453_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23908,13 +13207,7 @@ fn c1454_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23922,13 +13215,7 @@ fn c1455_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -23936,165 +13223,71 @@ fn c1456_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (54157613000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((54157613000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-54157613000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-54157613000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-54157613000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-54157613000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (54157613000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((54157613000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -24102,13 +13295,7 @@ fn c1465_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -24116,13 +13303,7 @@ fn c1466_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -24130,13 +13311,7 @@ fn c1467_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -24144,13 +13319,7 @@ fn c1468_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -24158,13 +13327,7 @@ fn c1469_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -24172,13 +13335,7 @@ fn c1470_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -24186,208 +13343,103 @@ fn c1471_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1473_l1491_assert_return_canonical_nan");
+    println!("Executing function {}", "c1473_l1491_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1473_l1491_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1474_l1492_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1474_l1492_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1474_l1492_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1475_l1493_assert_return_canonical_nan");
+    println!("Executing function {}", "c1475_l1493_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1475_l1493_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1476_l1494_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1476_l1494_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1476_l1494_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1477_l1495_assert_return_canonical_nan");
+    println!("Executing function {}", "c1477_l1495_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1477_l1495_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1478_l1496_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1478_l1496_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1478_l1496_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1479_l1497_assert_return_canonical_nan");
+    println!("Executing function {}", "c1479_l1497_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1479_l1497_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1480_l1498_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1480_l1498_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1480_l1498_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24395,10 +13447,7 @@ fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.0f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24422,13 +13471,7 @@ fn c1484_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24436,13 +13479,7 @@ fn c1485_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24450,13 +13487,7 @@ fn c1486_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24464,13 +13495,7 @@ fn c1487_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24478,13 +13503,7 @@ fn c1488_l1506_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24492,13 +13511,7 @@ fn c1489_l1507_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24506,13 +13519,7 @@ fn c1490_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24520,13 +13527,7 @@ fn c1491_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24534,10 +13535,7 @@ fn c1492_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24545,10 +13543,7 @@ fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.5f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24572,10 +13567,7 @@ fn c1496_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24583,10 +13575,7 @@ fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((1.0f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24610,10 +13599,7 @@ fn c1500_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24621,10 +13607,7 @@ fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24632,10 +13615,7 @@ fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24643,10 +13623,7 @@ fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24654,13 +13631,7 @@ fn c1504_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -24668,13 +13639,7 @@ fn c1505_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24682,13 +13647,7 @@ fn c1506_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24696,2082 +13655,1020 @@ fn c1507_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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), Value::F32(f32::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c1509_l1527_assert_return_canonical_nan");
+    println!("Executing function {}", "c1509_l1527_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1509_l1527_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32(f32::INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c1510_l1528_assert_return_canonical_nan");
+    println!("Executing function {}", "c1510_l1528_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1510_l1528_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32(f32::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c1511_l1529_assert_return_canonical_nan");
+    println!("Executing function {}", "c1511_l1529_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1511_l1529_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32(f32::INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c1512_l1530_assert_return_canonical_nan");
+    println!("Executing function {}", "c1512_l1530_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1512_l1530_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1513_l1531_assert_return_canonical_nan");
+    println!("Executing function {}", "c1513_l1531_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1513_l1531_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1514_l1532_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1514_l1532_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1514_l1532_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1515_l1533_assert_return_canonical_nan");
+    println!("Executing function {}", "c1515_l1533_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1515_l1533_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1516_l1534_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1516_l1534_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1516_l1534_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1517_l1535_assert_return_canonical_nan");
+    println!("Executing function {}", "c1517_l1535_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1517_l1535_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1518_l1536_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1518_l1536_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1518_l1536_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1519_l1537_assert_return_canonical_nan");
+    println!("Executing function {}", "c1519_l1537_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1519_l1537_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1520_l1538_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1520_l1538_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1520_l1538_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1521_l1539_assert_return_canonical_nan");
+    println!("Executing function {}", "c1521_l1539_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1521_l1539_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1522_l1540_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1522_l1540_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1522_l1540_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1523_l1541_assert_return_canonical_nan");
+    println!("Executing function {}", "c1523_l1541_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1523_l1541_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1524_l1542_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1524_l1542_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1524_l1542_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1525_l1543_assert_return_canonical_nan");
+    println!("Executing function {}", "c1525_l1543_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1525_l1543_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1526_l1544_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1526_l1544_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1526_l1544_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1527_l1545_assert_return_canonical_nan");
+    println!("Executing function {}", "c1527_l1545_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1527_l1545_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1528_l1546_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1528_l1546_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1528_l1546_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1529_l1547_assert_return_canonical_nan");
+    println!("Executing function {}", "c1529_l1547_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1529_l1547_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1530_l1548_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1530_l1548_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1530_l1548_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1531_l1549_assert_return_canonical_nan");
+    println!("Executing function {}", "c1531_l1549_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1531_l1549_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1532_l1550_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1532_l1550_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1532_l1550_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1533_l1551_assert_return_canonical_nan");
+    println!("Executing function {}", "c1533_l1551_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1533_l1551_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1534_l1552_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1534_l1552_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1534_l1552_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1535_l1553_assert_return_canonical_nan");
+    println!("Executing function {}", "c1535_l1553_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1535_l1553_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1536_l1554_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1536_l1554_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1536_l1554_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1537_l1555_assert_return_canonical_nan");
+    println!("Executing function {}", "c1537_l1555_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1537_l1555_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1538_l1556_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1538_l1556_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1538_l1556_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1539_l1557_assert_return_canonical_nan");
+    println!("Executing function {}", "c1539_l1557_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1539_l1557_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1540_l1558_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1540_l1558_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1540_l1558_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1541_l1559_assert_return_canonical_nan");
+    println!("Executing function {}", "c1541_l1559_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1541_l1559_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1542_l1560_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1542_l1560_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1542_l1560_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1543_l1561_assert_return_canonical_nan");
+    println!("Executing function {}", "c1543_l1561_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1543_l1561_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1544_l1562_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1544_l1562_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1544_l1562_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1545_l1563_assert_return_canonical_nan");
+    println!("Executing function {}", "c1545_l1563_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1545_l1563_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1546_l1564_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1546_l1564_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1546_l1564_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1547_l1565_assert_return_canonical_nan");
+    println!("Executing function {}", "c1547_l1565_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1547_l1565_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1548_l1566_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1548_l1566_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1548_l1566_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1549_l1567_assert_return_canonical_nan");
+    println!("Executing function {}", "c1549_l1567_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1549_l1567_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1550_l1568_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1550_l1568_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1550_l1568_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1551_l1569_assert_return_canonical_nan");
+    println!("Executing function {}", "c1551_l1569_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1551_l1569_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1552_l1570_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1552_l1570_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1552_l1570_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1553_l1571_assert_return_canonical_nan");
+    println!("Executing function {}", "c1553_l1571_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1553_l1571_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1554_l1572_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1554_l1572_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1554_l1572_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1555_l1573_assert_return_canonical_nan");
+    println!("Executing function {}", "c1555_l1573_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1555_l1573_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1556_l1574_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1556_l1574_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1556_l1574_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1557_l1575_assert_return_canonical_nan");
+    println!("Executing function {}", "c1557_l1575_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1557_l1575_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1558_l1576_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1558_l1576_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1558_l1576_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1559_l1577_assert_return_canonical_nan");
+    println!("Executing function {}", "c1559_l1577_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1559_l1577_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1560_l1578_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1560_l1578_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1560_l1578_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1561_l1579_assert_return_canonical_nan");
+    println!("Executing function {}", "c1561_l1579_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1561_l1579_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1562_l1580_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1562_l1580_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1562_l1580_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1563_l1581_assert_return_canonical_nan");
+    println!("Executing function {}", "c1563_l1581_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1563_l1581_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1564_l1582_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1564_l1582_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1564_l1582_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1565_l1583_assert_return_canonical_nan");
+    println!("Executing function {}", "c1565_l1583_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1565_l1583_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1566_l1584_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1566_l1584_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1566_l1584_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1567_l1585_assert_return_canonical_nan");
+    println!("Executing function {}", "c1567_l1585_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1567_l1585_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1568_l1586_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1568_l1586_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1568_l1586_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1569_l1587_assert_return_canonical_nan");
+    println!("Executing function {}", "c1569_l1587_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1569_l1587_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1570_l1588_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1570_l1588_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1570_l1588_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1571_l1589_assert_return_canonical_nan");
+    println!("Executing function {}", "c1571_l1589_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1571_l1589_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1572_l1590_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1572_l1590_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1572_l1590_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1573_l1591_assert_return_canonical_nan");
+    println!("Executing function {}", "c1573_l1591_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1573_l1591_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1574_l1592_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1574_l1592_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1574_l1592_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1575_l1593_assert_return_canonical_nan");
+    println!("Executing function {}", "c1575_l1593_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1575_l1593_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1576_l1594_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1576_l1594_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1576_l1594_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1577_l1595_assert_return_canonical_nan");
+    println!("Executing function {}", "c1577_l1595_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1577_l1595_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1578_l1596_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1578_l1596_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1578_l1596_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1579_l1597_assert_return_canonical_nan");
+    println!("Executing function {}", "c1579_l1597_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1579_l1597_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1580_l1598_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1580_l1598_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1580_l1598_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1581_l1599_assert_return_canonical_nan");
+    println!("Executing function {}", "c1581_l1599_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1581_l1599_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1582_l1600_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1582_l1600_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1582_l1600_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1583_l1601_assert_return_canonical_nan");
+    println!("Executing function {}", "c1583_l1601_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1583_l1601_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1584_l1602_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1584_l1602_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1584_l1602_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1585_l1603_assert_return_canonical_nan");
+    println!("Executing function {}", "c1585_l1603_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1585_l1603_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1586_l1604_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1586_l1604_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1586_l1604_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1587_l1605_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1587_l1605_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1587_l1605_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1588_l1606_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1588_l1606_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1588_l1606_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1589_l1607_assert_return_canonical_nan");
+    println!("Executing function {}", "c1589_l1607_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1589_l1607_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1590_l1608_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1590_l1608_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1590_l1608_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1591_l1609_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1591_l1609_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1591_l1609_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1592_l1610_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1592_l1610_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1592_l1610_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1593_l1611_assert_return_canonical_nan");
+    println!("Executing function {}", "c1593_l1611_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1593_l1611_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1594_l1612_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1594_l1612_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1594_l1612_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1595_l1613_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1595_l1613_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1595_l1613_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1596_l1614_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1596_l1614_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1596_l1614_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1597_l1615_assert_return_canonical_nan");
+    println!("Executing function {}", "c1597_l1615_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1597_l1615_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1598_l1616_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1598_l1616_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1598_l1616_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1599_l1617_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1599_l1617_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1599_l1617_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1600_l1618_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1600_l1618_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1600_l1618_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -26810,32 +14707,15 @@ fn c1604_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -26843,32 +14723,15 @@ fn c1606_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -26876,32 +14739,15 @@ fn c1608_l1626_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -26909,32 +14755,15 @@ fn c1610_l1628_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -27038,32 +14867,15 @@ fn c1624_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -27071,32 +14883,15 @@ fn c1626_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -27104,10 +14899,7 @@ fn c1628_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -27123,10 +14915,7 @@ fn c1630_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -27141,224 +14930,112 @@ fn c1632_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1633_l1651_assert_return_canonical_nan");
+    println!("Executing function {}", "c1633_l1651_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1633_l1651_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1634_l1652_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1634_l1652_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1634_l1652_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1635_l1653_assert_return_canonical_nan");
+    println!("Executing function {}", "c1635_l1653_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1635_l1653_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1636_l1654_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1636_l1654_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1636_l1654_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c1637_l1655_assert_return_canonical_nan");
+    println!("Executing function {}", "c1637_l1655_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1637_l1655_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c1638_l1656_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1638_l1656_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1638_l1656_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c1639_l1657_assert_return_canonical_nan");
+    println!("Executing function {}", "c1639_l1657_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1639_l1657_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c1640_l1658_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1640_l1658_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1640_l1658_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -27366,13 +15043,7 @@ fn c1643_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -27380,165 +15051,71 @@ fn c1644_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -27546,32 +15123,15 @@ fn c1653_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -27579,32 +15139,15 @@ fn c1655_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -27612,32 +15155,15 @@ fn c1657_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -27645,32 +15171,15 @@ fn c1659_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -27678,32 +15187,15 @@ fn c1661_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -27711,108 +15203,47 @@ fn c1663_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -27820,32 +15251,15 @@ fn c1669_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -27853,254 +15267,119 @@ fn c1671_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1673_l1691_assert_return_canonical_nan");
+    println!("Executing function {}", "c1673_l1691_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1673_l1691_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1674_l1692_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1674_l1692_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1674_l1692_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1675_l1693_assert_return_canonical_nan");
+    println!("Executing function {}", "c1675_l1693_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1675_l1693_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1676_l1694_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1676_l1694_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1676_l1694_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1677_l1695_assert_return_canonical_nan");
+    println!("Executing function {}", "c1677_l1695_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1677_l1695_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1678_l1696_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1678_l1696_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1678_l1696_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1679_l1697_assert_return_canonical_nan");
+    println!("Executing function {}", "c1679_l1697_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1679_l1697_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1680_l1698_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1680_l1698_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1680_l1698_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -28108,13 +15387,7 @@ fn c1683_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -28122,165 +15395,71 @@ fn c1684_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -28288,32 +15467,15 @@ fn c1693_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -28321,32 +15483,15 @@ fn c1695_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -28354,32 +15499,15 @@ fn c1697_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -28387,32 +15515,15 @@ fn c1699_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -28420,32 +15531,15 @@ fn c1701_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -28453,108 +15547,47 @@ fn c1703_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -28562,32 +15595,15 @@ fn c1709_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -28595,203 +15611,96 @@ fn c1711_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1713_l1731_assert_return_canonical_nan");
+    println!("Executing function {}", "c1713_l1731_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1713_l1731_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1714_l1732_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1714_l1732_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1714_l1732_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1715_l1733_assert_return_canonical_nan");
+    println!("Executing function {}", "c1715_l1733_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1715_l1733_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1716_l1734_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1716_l1734_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1716_l1734_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1717_l1735_assert_return_canonical_nan");
+    println!("Executing function {}", "c1717_l1735_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1717_l1735_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1718_l1736_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1718_l1736_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1718_l1736_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1719_l1737_assert_return_canonical_nan");
+    println!("Executing function {}", "c1719_l1737_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1719_l1737_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1720_l1738_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1720_l1738_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1720_l1738_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -28830,13 +15739,7 @@ fn c1724_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -28844,13 +15747,7 @@ fn c1725_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -28858,51 +15755,23 @@ fn c1726_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -28910,13 +15779,7 @@ fn c1729_l1747_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -28924,38 +15787,16 @@ fn c1730_l1748_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -29058,32 +15899,15 @@ fn c1744_l1762_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -29091,32 +15915,15 @@ fn c1746_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -29124,10 +15931,7 @@ fn c1748_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -29143,10 +15947,7 @@ fn c1750_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -29161,173 +15962,89 @@ fn c1752_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1753_l1771_assert_return_canonical_nan");
+    println!("Executing function {}", "c1753_l1771_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1753_l1771_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1754_l1772_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1754_l1772_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1754_l1772_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1755_l1773_assert_return_canonical_nan");
+    println!("Executing function {}", "c1755_l1773_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1755_l1773_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1756_l1774_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1756_l1774_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1756_l1774_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c1757_l1775_assert_return_canonical_nan");
+    println!("Executing function {}", "c1757_l1775_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1757_l1775_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c1758_l1776_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1758_l1776_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1758_l1776_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c1759_l1777_assert_return_canonical_nan");
+    println!("Executing function {}", "c1759_l1777_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1759_l1777_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c1760_l1778_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1760_l1778_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1760_l1778_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -29366,13 +16083,7 @@ fn c1764_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -29380,13 +16091,7 @@ fn c1765_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -29394,51 +16099,23 @@ fn c1766_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -29446,13 +16123,7 @@ fn c1769_l1787_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -29460,38 +16131,16 @@ fn c1770_l1788_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -29594,32 +16243,15 @@ fn c1784_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -29627,32 +16259,15 @@ fn c1786_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -29660,10 +16275,7 @@ fn c1788_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -29679,10 +16291,7 @@ fn c1790_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -29697,173 +16306,89 @@ fn c1792_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1793_l1811_assert_return_canonical_nan");
+    println!("Executing function {}", "c1793_l1811_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1793_l1811_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1794_l1812_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1794_l1812_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1794_l1812_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1795_l1813_assert_return_canonical_nan");
+    println!("Executing function {}", "c1795_l1813_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1795_l1813_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1796_l1814_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1796_l1814_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1796_l1814_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c1797_l1815_assert_return_canonical_nan");
+    println!("Executing function {}", "c1797_l1815_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1797_l1815_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c1798_l1816_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1798_l1816_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1798_l1816_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c1799_l1817_assert_return_canonical_nan");
+    println!("Executing function {}", "c1799_l1817_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1799_l1817_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c1800_l1818_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1800_l1818_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1800_l1818_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -29902,13 +16427,7 @@ fn c1804_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -29916,13 +16435,7 @@ fn c1805_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -29930,51 +16443,23 @@ fn c1806_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -29982,13 +16467,7 @@ fn c1809_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -29996,38 +16475,16 @@ fn c1810_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -30098,10 +16555,7 @@ fn c1820_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30109,10 +16563,7 @@ fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30120,10 +16571,7 @@ fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30131,10 +16579,7 @@ fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30142,32 +16587,15 @@ fn c1824_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30175,32 +16603,15 @@ fn c1826_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30208,10 +16619,7 @@ fn c1828_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -30219,10 +16627,7 @@ fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30230,10 +16635,7 @@ fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -30241,246 +16643,119 @@ fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1833_l1851_assert_return_canonical_nan");
+    println!("Executing function {}", "c1833_l1851_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1833_l1851_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1834_l1852_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1834_l1852_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1834_l1852_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1835_l1853_assert_return_canonical_nan");
+    println!("Executing function {}", "c1835_l1853_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1835_l1853_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1836_l1854_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1836_l1854_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1836_l1854_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1837_l1855_assert_return_canonical_nan");
+    println!("Executing function {}", "c1837_l1855_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1837_l1855_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1838_l1856_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1838_l1856_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1838_l1856_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1839_l1857_assert_return_canonical_nan");
+    println!("Executing function {}", "c1839_l1857_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1839_l1857_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1840_l1858_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1840_l1858_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1840_l1858_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -30488,13 +16763,7 @@ fn c1843_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -30502,203 +16771,87 @@ fn c1844_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -30706,13 +16859,7 @@ fn c1855_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -30720,51 +16867,23 @@ fn c1856_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -30772,13 +16891,7 @@ fn c1859_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -30786,51 +16899,23 @@ fn c1860_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30838,13 +16923,7 @@ fn c1863_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -30852,89 +16931,39 @@ fn c1864_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -30942,32 +16971,15 @@ fn c1869_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -30975,213 +16987,103 @@ fn c1871_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1873_l1891_assert_return_canonical_nan");
+    println!("Executing function {}", "c1873_l1891_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1873_l1891_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1874_l1892_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1874_l1892_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1874_l1892_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1875_l1893_assert_return_canonical_nan");
+    println!("Executing function {}", "c1875_l1893_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1875_l1893_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1876_l1894_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1876_l1894_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1876_l1894_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1877_l1895_assert_return_canonical_nan");
+    println!("Executing function {}", "c1877_l1895_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1877_l1895_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1878_l1896_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1878_l1896_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1878_l1896_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1879_l1897_assert_return_canonical_nan");
+    println!("Executing function {}", "c1879_l1897_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1879_l1897_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1880_l1898_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1880_l1898_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1880_l1898_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31189,10 +17091,7 @@ fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.0f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31216,13 +17115,7 @@ fn c1884_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31230,13 +17123,7 @@ fn c1885_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31244,51 +17131,23 @@ fn c1886_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31296,13 +17155,7 @@ fn c1889_l1907_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31310,48 +17163,23 @@ fn c1890_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31359,10 +17187,7 @@ fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.5f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31386,10 +17211,7 @@ fn c1896_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31397,10 +17219,7 @@ fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((1.0f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31424,10 +17243,7 @@ fn c1900_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31435,10 +17251,7 @@ fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31446,10 +17259,7 @@ fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -31457,10 +17267,7 @@ fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -31468,13 +17275,7 @@ fn c1904_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31482,13 +17283,7 @@ fn c1905_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31496,48 +17291,23 @@ fn c1906_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31545,10 +17315,7 @@ fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31556,10 +17323,7 @@ fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -31567,1999 +17331,976 @@ fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1913_l1931_assert_return_canonical_nan");
+    println!("Executing function {}", "c1913_l1931_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1913_l1931_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1914_l1932_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1914_l1932_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1914_l1932_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1915_l1933_assert_return_canonical_nan");
+    println!("Executing function {}", "c1915_l1933_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1915_l1933_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1916_l1934_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1916_l1934_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1916_l1934_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1917_l1935_assert_return_canonical_nan");
+    println!("Executing function {}", "c1917_l1935_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1917_l1935_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1918_l1936_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1918_l1936_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1918_l1936_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1919_l1937_assert_return_canonical_nan");
+    println!("Executing function {}", "c1919_l1937_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1919_l1937_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1920_l1938_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1920_l1938_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1920_l1938_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1921_l1939_assert_return_canonical_nan");
+    println!("Executing function {}", "c1921_l1939_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1921_l1939_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1922_l1940_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1922_l1940_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1922_l1940_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1923_l1941_assert_return_canonical_nan");
+    println!("Executing function {}", "c1923_l1941_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1923_l1941_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1924_l1942_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1924_l1942_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1924_l1942_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1925_l1943_assert_return_canonical_nan");
+    println!("Executing function {}", "c1925_l1943_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1925_l1943_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1926_l1944_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1926_l1944_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1926_l1944_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1927_l1945_assert_return_canonical_nan");
+    println!("Executing function {}", "c1927_l1945_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1927_l1945_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1928_l1946_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1928_l1946_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1928_l1946_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1929_l1947_assert_return_canonical_nan");
+    println!("Executing function {}", "c1929_l1947_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1929_l1947_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1930_l1948_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1930_l1948_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1930_l1948_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1931_l1949_assert_return_canonical_nan");
+    println!("Executing function {}", "c1931_l1949_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1931_l1949_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1932_l1950_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1932_l1950_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1932_l1950_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1933_l1951_assert_return_canonical_nan");
+    println!("Executing function {}", "c1933_l1951_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1933_l1951_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1934_l1952_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1934_l1952_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1934_l1952_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1935_l1953_assert_return_canonical_nan");
+    println!("Executing function {}", "c1935_l1953_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1935_l1953_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1936_l1954_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1936_l1954_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1936_l1954_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1937_l1955_assert_return_canonical_nan");
+    println!("Executing function {}", "c1937_l1955_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1937_l1955_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1938_l1956_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1938_l1956_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1938_l1956_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1939_l1957_assert_return_canonical_nan");
+    println!("Executing function {}", "c1939_l1957_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1939_l1957_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1940_l1958_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1940_l1958_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1940_l1958_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1941_l1959_assert_return_canonical_nan");
+    println!("Executing function {}", "c1941_l1959_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1941_l1959_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1942_l1960_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1942_l1960_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1942_l1960_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1943_l1961_assert_return_canonical_nan");
+    println!("Executing function {}", "c1943_l1961_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1943_l1961_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1944_l1962_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1944_l1962_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1944_l1962_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1945_l1963_assert_return_canonical_nan");
+    println!("Executing function {}", "c1945_l1963_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1945_l1963_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1946_l1964_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1946_l1964_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1946_l1964_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1947_l1965_assert_return_canonical_nan");
+    println!("Executing function {}", "c1947_l1965_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1947_l1965_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1948_l1966_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1948_l1966_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1948_l1966_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1949_l1967_assert_return_canonical_nan");
+    println!("Executing function {}", "c1949_l1967_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1949_l1967_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1950_l1968_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1950_l1968_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1950_l1968_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1951_l1969_assert_return_canonical_nan");
+    println!("Executing function {}", "c1951_l1969_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1951_l1969_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1952_l1970_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1952_l1970_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1952_l1970_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1953_l1971_assert_return_canonical_nan");
+    println!("Executing function {}", "c1953_l1971_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1953_l1971_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1954_l1972_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1954_l1972_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1954_l1972_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1955_l1973_assert_return_canonical_nan");
+    println!("Executing function {}", "c1955_l1973_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1955_l1973_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1956_l1974_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1956_l1974_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1956_l1974_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1957_l1975_assert_return_canonical_nan");
+    println!("Executing function {}", "c1957_l1975_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1957_l1975_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1958_l1976_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1958_l1976_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1958_l1976_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1959_l1977_assert_return_canonical_nan");
+    println!("Executing function {}", "c1959_l1977_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1959_l1977_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c1960_l1978_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1960_l1978_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1960_l1978_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1961_l1979_assert_return_canonical_nan");
+    println!("Executing function {}", "c1961_l1979_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1961_l1979_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1962_l1980_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1962_l1980_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1962_l1980_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1963_l1981_assert_return_canonical_nan");
+    println!("Executing function {}", "c1963_l1981_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1963_l1981_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1964_l1982_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1964_l1982_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1964_l1982_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1965_l1983_assert_return_canonical_nan");
+    println!("Executing function {}", "c1965_l1983_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1965_l1983_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1966_l1984_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1966_l1984_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1966_l1984_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1967_l1985_assert_return_canonical_nan");
+    println!("Executing function {}", "c1967_l1985_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1967_l1985_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1968_l1986_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1968_l1986_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1968_l1986_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1969_l1987_assert_return_canonical_nan");
+    println!("Executing function {}", "c1969_l1987_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1969_l1987_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1970_l1988_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1970_l1988_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1970_l1988_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1971_l1989_assert_return_canonical_nan");
+    println!("Executing function {}", "c1971_l1989_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1971_l1989_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1972_l1990_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1972_l1990_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1972_l1990_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1973_l1991_assert_return_canonical_nan");
+    println!("Executing function {}", "c1973_l1991_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1973_l1991_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1974_l1992_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1974_l1992_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1974_l1992_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1975_l1993_assert_return_canonical_nan");
+    println!("Executing function {}", "c1975_l1993_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1975_l1993_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1976_l1994_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1976_l1994_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1976_l1994_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1977_l1995_assert_return_canonical_nan");
+    println!("Executing function {}", "c1977_l1995_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1977_l1995_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1978_l1996_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1978_l1996_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1978_l1996_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1979_l1997_assert_return_canonical_nan");
+    println!("Executing function {}", "c1979_l1997_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1979_l1997_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1980_l1998_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1980_l1998_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1980_l1998_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1981_l1999_assert_return_canonical_nan");
+    println!("Executing function {}", "c1981_l1999_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1981_l1999_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1982_l2000_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1982_l2000_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1982_l2000_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1983_l2001_assert_return_canonical_nan");
+    println!("Executing function {}", "c1983_l2001_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1983_l2001_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1984_l2002_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1984_l2002_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1984_l2002_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1985_l2003_assert_return_canonical_nan");
+    println!("Executing function {}", "c1985_l2003_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1985_l2003_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1986_l2004_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1986_l2004_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1986_l2004_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1987_l2005_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1987_l2005_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1987_l2005_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1988_l2006_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1988_l2006_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1988_l2006_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1989_l2007_assert_return_canonical_nan");
+    println!("Executing function {}", "c1989_l2007_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1989_l2007_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1990_l2008_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1990_l2008_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1990_l2008_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1991_l2009_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1991_l2009_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1991_l2009_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1992_l2010_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1992_l2010_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1992_l2010_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1993_l2011_assert_return_canonical_nan");
+    println!("Executing function {}", "c1993_l2011_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1993_l2011_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1994_l2012_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1994_l2012_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1994_l2012_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1995_l2013_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1995_l2013_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1995_l2013_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1996_l2014_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1996_l2014_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1996_l2014_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1997_l2015_assert_return_canonical_nan");
+    println!("Executing function {}", "c1997_l2015_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1997_l2015_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1998_l2016_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1998_l2016_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1998_l2016_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1999_l2017_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1999_l2017_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1999_l2017_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2000_l2018_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2000_l2018_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2000_l2018_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -33598,13 +18339,7 @@ fn c2004_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -33612,32 +18347,15 @@ fn c2005_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -33645,32 +18363,15 @@ fn c2007_l2025_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -33678,32 +18379,15 @@ fn c2009_l2027_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -33711,19 +18395,8 @@ fn c2011_l2029_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -33826,13 +18499,7 @@ fn c2024_l2042_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -33840,32 +18507,15 @@ fn c2025_l2043_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -33873,29 +18523,15 @@ fn c2027_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -33911,10 +18547,7 @@ fn c2030_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -33929,186 +18562,96 @@ fn c2032_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2033_l2051_assert_return_canonical_nan");
+    println!("Executing function {}", "c2033_l2051_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2033_l2051_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2034_l2052_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2034_l2052_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2034_l2052_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2035_l2053_assert_return_canonical_nan");
+    println!("Executing function {}", "c2035_l2053_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2035_l2053_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2036_l2054_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2036_l2054_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2036_l2054_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c2037_l2055_assert_return_canonical_nan");
+    println!("Executing function {}", "c2037_l2055_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2037_l2055_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c2038_l2056_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2038_l2056_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2038_l2056_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c2039_l2057_assert_return_canonical_nan");
+    println!("Executing function {}", "c2039_l2057_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2039_l2057_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c2040_l2058_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2040_l2058_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2040_l2058_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -34116,13 +18659,7 @@ fn c2041_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -34130,222 +18667,95 @@ fn c2042_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -34353,32 +18763,15 @@ fn c2054_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -34386,32 +18779,15 @@ fn c2056_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -34419,32 +18795,15 @@ fn c2058_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -34452,32 +18811,15 @@ fn c2060_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -34485,32 +18827,15 @@ fn c2062_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -34518,108 +18843,47 @@ fn c2064_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -34627,230 +18891,111 @@ fn c2070_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2073_l2091_assert_return_canonical_nan");
+    println!("Executing function {}", "c2073_l2091_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2073_l2091_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2074_l2092_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2074_l2092_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2074_l2092_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2075_l2093_assert_return_canonical_nan");
+    println!("Executing function {}", "c2075_l2093_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2075_l2093_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2076_l2094_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2076_l2094_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2076_l2094_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2077_l2095_assert_return_canonical_nan");
+    println!("Executing function {}", "c2077_l2095_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2077_l2095_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2078_l2096_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2078_l2096_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2078_l2096_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2079_l2097_assert_return_canonical_nan");
+    println!("Executing function {}", "c2079_l2097_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2079_l2097_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2080_l2098_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2080_l2098_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2080_l2098_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -34858,13 +19003,7 @@ fn c2081_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -34872,222 +19011,95 @@ fn c2082_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -35095,32 +19107,15 @@ fn c2094_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -35128,32 +19123,15 @@ fn c2096_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -35161,32 +19139,15 @@ fn c2098_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -35194,32 +19155,15 @@ fn c2100_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -35227,32 +19171,15 @@ fn c2102_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -35260,108 +19187,47 @@ fn c2104_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -35369,217 +19235,104 @@ fn c2110_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2113_l2131_assert_return_canonical_nan");
+    println!("Executing function {}", "c2113_l2131_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2113_l2131_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2114_l2132_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2114_l2132_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2114_l2132_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2115_l2133_assert_return_canonical_nan");
+    println!("Executing function {}", "c2115_l2133_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2115_l2133_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2116_l2134_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2116_l2134_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2116_l2134_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2117_l2135_assert_return_canonical_nan");
+    println!("Executing function {}", "c2117_l2135_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2117_l2135_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2118_l2136_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2118_l2136_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2118_l2136_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2119_l2137_assert_return_canonical_nan");
+    println!("Executing function {}", "c2119_l2137_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2119_l2137_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2120_l2138_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2120_l2138_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2120_l2138_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -35618,51 +19371,23 @@ fn c2124_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -35670,13 +19395,7 @@ fn c2127_l2145_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -35684,51 +19403,23 @@ fn c2128_l2146_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -35736,13 +19427,7 @@ fn c2131_l2149_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -35846,13 +19531,7 @@ fn c2144_l2162_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -35860,32 +19539,15 @@ fn c2145_l2163_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -35893,29 +19555,15 @@ fn c2147_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -35931,10 +19579,7 @@ fn c2150_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -35949,173 +19594,89 @@ fn c2152_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2153_l2171_assert_return_canonical_nan");
+    println!("Executing function {}", "c2153_l2171_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2153_l2171_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2154_l2172_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2154_l2172_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2154_l2172_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2155_l2173_assert_return_canonical_nan");
+    println!("Executing function {}", "c2155_l2173_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2155_l2173_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2156_l2174_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2156_l2174_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2156_l2174_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c2157_l2175_assert_return_canonical_nan");
+    println!("Executing function {}", "c2157_l2175_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2157_l2175_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c2158_l2176_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2158_l2176_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2158_l2176_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c2159_l2177_assert_return_canonical_nan");
+    println!("Executing function {}", "c2159_l2177_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2159_l2177_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c2160_l2178_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2160_l2178_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2160_l2178_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -36154,51 +19715,23 @@ fn c2164_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -36206,13 +19739,7 @@ fn c2167_l2185_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -36220,51 +19747,23 @@ fn c2168_l2186_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -36272,13 +19771,7 @@ fn c2171_l2189_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -36382,13 +19875,7 @@ fn c2184_l2202_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -36396,32 +19883,15 @@ fn c2185_l2203_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -36429,29 +19899,15 @@ fn c2187_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -36467,10 +19923,7 @@ fn c2190_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -36485,173 +19938,89 @@ fn c2192_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2193_l2211_assert_return_canonical_nan");
+    println!("Executing function {}", "c2193_l2211_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2193_l2211_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2194_l2212_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2194_l2212_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2194_l2212_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2195_l2213_assert_return_canonical_nan");
+    println!("Executing function {}", "c2195_l2213_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2195_l2213_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2196_l2214_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2196_l2214_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2196_l2214_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4290772992))],
-        )
-        .unwrap()
-        .expect("Missing result in c2197_l2215_assert_return_canonical_nan");
+    println!("Executing function {}", "c2197_l2215_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2197_l2215_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(4288675840))],
-        )
-        .unwrap()
-        .expect("Missing result in c2198_l2216_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2198_l2216_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2198_l2216_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2143289344))],
-        )
-        .unwrap()
-        .expect("Missing result in c2199_l2217_assert_return_canonical_nan");
+    println!("Executing function {}", "c2199_l2217_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2199_l2217_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32(f32::from_bits(2141192192))],
-        )
-        .unwrap()
-        .expect("Missing result in c2200_l2218_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2200_l2218_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2200_l2218_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -36690,51 +20059,23 @@ fn c2204_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36742,13 +20083,7 @@ fn c2207_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36756,51 +20091,23 @@ fn c2208_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36808,13 +20115,7 @@ fn c2211_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36886,10 +20187,7 @@ fn c2220_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36897,10 +20195,7 @@ fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36908,10 +20203,7 @@ fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36919,10 +20211,7 @@ fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36930,13 +20219,7 @@ fn c2224_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36944,32 +20227,15 @@ fn c2225_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -36977,29 +20243,15 @@ fn c2227_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -37007,10 +20259,7 @@ fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -37018,10 +20267,7 @@ fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -37029,208 +20275,103 @@ fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2233_l2251_assert_return_canonical_nan");
+    println!("Executing function {}", "c2233_l2251_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2233_l2251_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2234_l2252_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2234_l2252_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2234_l2252_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2235_l2253_assert_return_canonical_nan");
+    println!("Executing function {}", "c2235_l2253_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2235_l2253_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2236_l2254_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2236_l2254_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2236_l2254_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2237_l2255_assert_return_canonical_nan");
+    println!("Executing function {}", "c2237_l2255_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2237_l2255_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2238_l2256_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2238_l2256_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2238_l2256_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2239_l2257_assert_return_canonical_nan");
+    println!("Executing function {}", "c2239_l2257_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2239_l2257_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2240_l2258_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2240_l2258_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2240_l2258_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -37238,13 +20379,7 @@ fn c2241_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -37252,203 +20387,87 @@ fn c2242_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -37456,13 +20475,7 @@ fn c2253_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -37470,51 +20483,23 @@ fn c2254_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -37522,13 +20507,7 @@ fn c2257_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -37536,51 +20515,23 @@ fn c2258_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -37588,13 +20539,7 @@ fn c2261_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -37602,146 +20547,63 @@ fn c2262_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -37749,227 +20611,111 @@ fn c2270_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2273_l2291_assert_return_canonical_nan");
+    println!("Executing function {}", "c2273_l2291_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2273_l2291_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2274_l2292_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2274_l2292_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2274_l2292_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2275_l2293_assert_return_canonical_nan");
+    println!("Executing function {}", "c2275_l2293_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2275_l2293_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2276_l2294_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2276_l2294_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2276_l2294_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2277_l2295_assert_return_canonical_nan");
+    println!("Executing function {}", "c2277_l2295_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2277_l2295_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2278_l2296_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2278_l2296_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2278_l2296_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2279_l2297_assert_return_canonical_nan");
+    println!("Executing function {}", "c2279_l2297_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2279_l2297_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2280_l2298_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2280_l2298_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2280_l2298_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -37977,10 +20723,7 @@ fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.0f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -38004,51 +20747,23 @@ fn c2284_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38056,13 +20771,7 @@ fn c2287_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38070,51 +20779,23 @@ fn c2288_l2306_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38122,13 +20803,7 @@ fn c2291_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38136,10 +20811,7 @@ fn c2292_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -38147,10 +20819,7 @@ fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.5f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -38174,10 +20843,7 @@ fn c2296_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -38185,10 +20851,7 @@ fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((1.0f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -38212,10 +20875,7 @@ fn c2300_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -38223,10 +20883,7 @@ fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -38234,10 +20891,7 @@ fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38245,10 +20899,7 @@ fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38256,51 +20907,23 @@ fn c2304_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38308,13 +20931,7 @@ fn c2307_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38322,10 +20939,7 @@ fn c2308_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -38333,10 +20947,7 @@ fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38344,10 +20955,7 @@ fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -38355,1999 +20963,976 @@ fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2313_l2331_assert_return_canonical_nan");
+    println!("Executing function {}", "c2313_l2331_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2313_l2331_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2314_l2332_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2314_l2332_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2314_l2332_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2315_l2333_assert_return_canonical_nan");
+    println!("Executing function {}", "c2315_l2333_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2315_l2333_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2316_l2334_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2316_l2334_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2316_l2334_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2317_l2335_assert_return_canonical_nan");
+    println!("Executing function {}", "c2317_l2335_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2317_l2335_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2318_l2336_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2318_l2336_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2318_l2336_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2319_l2337_assert_return_canonical_nan");
+    println!("Executing function {}", "c2319_l2337_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2319_l2337_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2320_l2338_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2320_l2338_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2320_l2338_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2321_l2339_assert_return_canonical_nan");
+    println!("Executing function {}", "c2321_l2339_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c2321_l2339_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2322_l2340_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2322_l2340_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c2322_l2340_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2323_l2341_assert_return_canonical_nan");
+    println!("Executing function {}", "c2323_l2341_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c2323_l2341_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2324_l2342_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2324_l2342_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c2324_l2342_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2325_l2343_assert_return_canonical_nan");
+    println!("Executing function {}", "c2325_l2343_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c2325_l2343_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2326_l2344_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2326_l2344_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c2326_l2344_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2327_l2345_assert_return_canonical_nan");
+    println!("Executing function {}", "c2327_l2345_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c2327_l2345_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2328_l2346_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2328_l2346_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c2328_l2346_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2329_l2347_assert_return_canonical_nan");
+    println!("Executing function {}", "c2329_l2347_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2329_l2347_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2330_l2348_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2330_l2348_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2330_l2348_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2331_l2349_assert_return_canonical_nan");
+    println!("Executing function {}", "c2331_l2349_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2331_l2349_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2332_l2350_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2332_l2350_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2332_l2350_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2333_l2351_assert_return_canonical_nan");
+    println!("Executing function {}", "c2333_l2351_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2333_l2351_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2334_l2352_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2334_l2352_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2334_l2352_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2335_l2353_assert_return_canonical_nan");
+    println!("Executing function {}", "c2335_l2353_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2335_l2353_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000000000001f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2336_l2354_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2336_l2354_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2336_l2354_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2337_l2355_assert_return_canonical_nan");
+    println!("Executing function {}", "c2337_l2355_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2337_l2355_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2338_l2356_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2338_l2356_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2338_l2356_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2339_l2357_assert_return_canonical_nan");
+    println!("Executing function {}", "c2339_l2357_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2339_l2357_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2340_l2358_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2340_l2358_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2340_l2358_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2341_l2359_assert_return_canonical_nan");
+    println!("Executing function {}", "c2341_l2359_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2341_l2359_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2342_l2360_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2342_l2360_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2342_l2360_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2343_l2361_assert_return_canonical_nan");
+    println!("Executing function {}", "c2343_l2361_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2343_l2361_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((0.000000000000000000000000000000000000011754944f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2344_l2362_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2344_l2362_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2344_l2362_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2345_l2363_assert_return_canonical_nan");
+    println!("Executing function {}", "c2345_l2363_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2345_l2363_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2346_l2364_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2346_l2364_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2346_l2364_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2347_l2365_assert_return_canonical_nan");
+    println!("Executing function {}", "c2347_l2365_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c2347_l2365_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2348_l2366_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2348_l2366_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c2348_l2366_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2349_l2367_assert_return_canonical_nan");
+    println!("Executing function {}", "c2349_l2367_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2349_l2367_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-0.5f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2350_l2368_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2350_l2368_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2350_l2368_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2351_l2369_assert_return_canonical_nan");
+    println!("Executing function {}", "c2351_l2369_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c2351_l2369_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((0.5f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2352_l2370_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2352_l2370_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c2352_l2370_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2353_l2371_assert_return_canonical_nan");
+    println!("Executing function {}", "c2353_l2371_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2353_l2371_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2354_l2372_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2354_l2372_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2354_l2372_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2355_l2373_assert_return_canonical_nan");
+    println!("Executing function {}", "c2355_l2373_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c2355_l2373_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2356_l2374_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2356_l2374_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c2356_l2374_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2357_l2375_assert_return_canonical_nan");
+    println!("Executing function {}", "c2357_l2375_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2357_l2375_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-1.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2358_l2376_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2358_l2376_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2358_l2376_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2359_l2377_assert_return_canonical_nan");
+    println!("Executing function {}", "c2359_l2377_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c2359_l2377_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((1.0f32))],
-        )
-        .unwrap()
-        .expect("Missing result in c2360_l2378_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2360_l2378_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c2360_l2378_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2361_l2379_assert_return_canonical_nan");
+    println!("Executing function {}", "c2361_l2379_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2361_l2379_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2362_l2380_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2362_l2380_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2362_l2380_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2363_l2381_assert_return_canonical_nan");
+    println!("Executing function {}", "c2363_l2381_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c2363_l2381_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2364_l2382_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2364_l2382_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c2364_l2382_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2365_l2383_assert_return_canonical_nan");
+    println!("Executing function {}", "c2365_l2383_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2365_l2383_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2366_l2384_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2366_l2384_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2366_l2384_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2367_l2385_assert_return_canonical_nan");
+    println!("Executing function {}", "c2367_l2385_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c2367_l2385_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((6.2831855f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2368_l2386_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2368_l2386_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c2368_l2386_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2369_l2387_assert_return_canonical_nan");
+    println!("Executing function {}", "c2369_l2387_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2369_l2387_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2370_l2388_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2370_l2388_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2370_l2388_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2371_l2389_assert_return_canonical_nan");
+    println!("Executing function {}", "c2371_l2389_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2371_l2389_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2372_l2390_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2372_l2390_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2372_l2390_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2373_l2391_assert_return_canonical_nan");
+    println!("Executing function {}", "c2373_l2391_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2373_l2391_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((-340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2374_l2392_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2374_l2392_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2374_l2392_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2375_l2393_assert_return_canonical_nan");
+    println!("Executing function {}", "c2375_l2393_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2375_l2393_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32((340282350000000000000000000000000000000.0f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2376_l2394_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2376_l2394_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2376_l2394_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2377_l2395_assert_return_canonical_nan");
+    println!("Executing function {}", "c2377_l2395_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2377_l2395_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2378_l2396_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2378_l2396_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2378_l2396_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2379_l2397_assert_return_canonical_nan");
+    println!("Executing function {}", "c2379_l2397_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c2379_l2397_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2380_l2398_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2380_l2398_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c2380_l2398_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2381_l2399_assert_return_canonical_nan");
+    println!("Executing function {}", "c2381_l2399_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2381_l2399_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2382_l2400_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2382_l2400_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2382_l2400_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2383_l2401_assert_return_canonical_nan");
+    println!("Executing function {}", "c2383_l2401_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c2383_l2401_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2384_l2402_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2384_l2402_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c2384_l2402_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2385_l2403_assert_return_canonical_nan");
+    println!("Executing function {}", "c2385_l2403_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2385_l2403_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2386_l2404_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2386_l2404_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2386_l2404_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2387_l2405_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2387_l2405_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2387_l2405_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2388_l2406_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2388_l2406_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2388_l2406_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2389_l2407_assert_return_canonical_nan");
+    println!("Executing function {}", "c2389_l2407_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2389_l2407_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2390_l2408_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2390_l2408_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2390_l2408_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2391_l2409_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2391_l2409_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2391_l2409_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2392_l2410_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2392_l2410_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2392_l2410_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2393_l2411_assert_return_canonical_nan");
+    println!("Executing function {}", "c2393_l2411_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2393_l2411_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4290772992)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2394_l2412_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2394_l2412_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2394_l2412_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2395_l2413_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2395_l2413_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2395_l2413_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(4288675840)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2396_l2414_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2396_l2414_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2396_l2414_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2397_l2415_assert_return_canonical_nan");
+    println!("Executing function {}", "c2397_l2415_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2397_l2415_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2143289344)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2398_l2416_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2398_l2416_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2398_l2416_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2399_l2417_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2399_l2417_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2399_l2417_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F32(f32::from_bits(2141192192)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2400_l2418_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2400_l2418_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2400_l2418_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -40369,94 +21954,50 @@ fn c2402_l2420_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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),
-            )],
-        )
-        .unwrap()
-        .expect("Missing result in c2403_l2421_assert_return_canonical_nan");
+    println!("Executing function {}", "c2403_l2421_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2403_l2421_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.00000000000000000000003743392f32))))
-    );
+    let result = instance.call("sqrt", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000003743392f32)))));
     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),
-            )],
-        )
-        .unwrap()
-        .expect("Missing result in c2405_l2423_assert_return_canonical_nan");
+    println!("Executing function {}", "c2405_l2423_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2405_l2423_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.00000000000000000010842022f32))))
-    );
+    let result = instance.call("sqrt", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000010842022f32)))));
     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))])
-        .unwrap()
-        .expect("Missing result in c2407_l2425_assert_return_canonical_nan");
+    println!("Executing function {}", "c2407_l2425_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2407_l2425_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -40470,18 +22011,12 @@ fn c2408_l2426_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2409_l2427_assert_return_canonical_nan");
+    println!("Executing function {}", "c2409_l2427_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2409_l2427_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -40495,18 +22030,12 @@ fn c2410_l2428_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2411_l2429_assert_return_canonical_nan");
+    println!("Executing function {}", "c2411_l2429_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2411_l2429_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -40520,49 +22049,31 @@ fn c2412_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c2413_l2431_assert_return_canonical_nan");
+    println!("Executing function {}", "c2413_l2431_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2413_l2431_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-    );
+    let result = instance.call("sqrt", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((18446743000000000000.0f32)))));
     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)])
-        .unwrap()
-        .expect("Missing result in c2415_l2433_assert_return_canonical_nan");
+    println!("Executing function {}", "c2415_l2433_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2415_l2433_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -40576,69 +22087,45 @@ fn c2416_l2434_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2417_l2435_assert_return_canonical_nan");
+    println!("Executing function {}", "c2417_l2435_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2417_l2435_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2418_l2436_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2418_l2436_assert_return_arithmetic_nan");
+    let result = instance.call("sqrt", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2418_l2436_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2419_l2437_assert_return_canonical_nan");
+    println!("Executing function {}", "c2419_l2437_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2419_l2437_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2420_l2438_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2420_l2438_assert_return_arithmetic_nan");
+    let result = instance.call("sqrt", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2420_l2438_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -40661,12 +22148,7 @@ fn c2422_l2440_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("floor", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -40674,12 +22156,7 @@ fn c2423_l2441_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("floor", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -40687,12 +22164,7 @@ fn c2424_l2442_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("floor", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -40700,12 +22172,7 @@ fn c2425_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("floor", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -40761,32 +22228,16 @@ fn c2432_l2450_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("floor", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("floor", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -40808,69 +22259,45 @@ fn c2436_l2454_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2437_l2455_assert_return_canonical_nan");
+    println!("Executing function {}", "c2437_l2455_assert_return_canonical_nan");
+    let result = instance.call("floor", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2437_l2455_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2438_l2456_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2438_l2456_assert_return_arithmetic_nan");
+    let result = instance.call("floor", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2438_l2456_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2439_l2457_assert_return_canonical_nan");
+    println!("Executing function {}", "c2439_l2457_assert_return_canonical_nan");
+    let result = instance.call("floor", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2439_l2457_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2440_l2458_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2440_l2458_assert_return_arithmetic_nan");
+    let result = instance.call("floor", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2440_l2458_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -40893,12 +22320,7 @@ fn c2442_l2460_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("ceil", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -40906,12 +22328,7 @@ fn c2443_l2461_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("ceil", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -40919,12 +22336,7 @@ fn c2444_l2462_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("ceil", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -40932,12 +22344,7 @@ fn c2445_l2463_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("ceil", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -40993,32 +22400,16 @@ fn c2452_l2470_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("ceil", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("ceil", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -41040,69 +22431,45 @@ fn c2456_l2474_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2457_l2475_assert_return_canonical_nan");
+    println!("Executing function {}", "c2457_l2475_assert_return_canonical_nan");
+    let result = instance.call("ceil", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2457_l2475_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2458_l2476_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2458_l2476_assert_return_arithmetic_nan");
+    let result = instance.call("ceil", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2458_l2476_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2459_l2477_assert_return_canonical_nan");
+    println!("Executing function {}", "c2459_l2477_assert_return_canonical_nan");
+    let result = instance.call("ceil", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2459_l2477_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2460_l2478_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2460_l2478_assert_return_arithmetic_nan");
+    let result = instance.call("ceil", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2460_l2478_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -41125,12 +22492,7 @@ fn c2462_l2480_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("trunc", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -41138,12 +22500,7 @@ fn c2463_l2481_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("trunc", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -41151,12 +22508,7 @@ fn c2464_l2482_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("trunc", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -41164,12 +22516,7 @@ fn c2465_l2483_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("trunc", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -41225,32 +22572,16 @@ fn c2472_l2490_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("trunc", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("trunc", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -41272,69 +22603,45 @@ fn c2476_l2494_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2477_l2495_assert_return_canonical_nan");
+    println!("Executing function {}", "c2477_l2495_assert_return_canonical_nan");
+    let result = instance.call("trunc", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2477_l2495_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2478_l2496_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2478_l2496_assert_return_arithmetic_nan");
+    let result = instance.call("trunc", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2478_l2496_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2479_l2497_assert_return_canonical_nan");
+    println!("Executing function {}", "c2479_l2497_assert_return_canonical_nan");
+    let result = instance.call("trunc", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2479_l2497_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2480_l2498_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2480_l2498_assert_return_arithmetic_nan");
+    let result = instance.call("trunc", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2480_l2498_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -41357,12 +22664,7 @@ fn c2482_l2500_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("nearest", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -41370,12 +22672,7 @@ fn c2483_l2501_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("nearest", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -41383,12 +22680,7 @@ fn c2484_l2502_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("nearest", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -41396,12 +22688,7 @@ fn c2485_l2503_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
+    let result = instance.call("nearest", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -41457,32 +22744,16 @@ fn c2492_l2510_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("nearest", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("nearest", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -41504,69 +22775,45 @@ fn c2496_l2514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2497_l2515_assert_return_canonical_nan");
+    println!("Executing function {}", "c2497_l2515_assert_return_canonical_nan");
+    let result = instance.call("nearest", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2497_l2515_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2498_l2516_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2498_l2516_assert_return_arithmetic_nan");
+    let result = instance.call("nearest", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2498_l2516_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2499_l2517_assert_return_canonical_nan");
+    println!("Executing function {}", "c2499_l2517_assert_return_canonical_nan");
+    let result = instance.call("nearest", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2499_l2517_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2500_l2518_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2500_l2518_assert_return_arithmetic_nan");
+    let result = instance.call("nearest", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2500_l2518_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
diff --git a/lib/runtime/tests/spectests/f32_bitwise.rs b/lib/runtime/tests/spectests/f32_bitwise.rs
index 7fd73878b..005e1b33b 100644
--- a/lib/runtime/tests/spectests/f32_bitwise.rs
+++ b/lib/runtime/tests/spectests/f32_bitwise.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 4
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f32 f32) (result f32)))
@@ -34,11 +38,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -81,13 +82,7 @@ fn c4_l13_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -95,13 +90,7 @@ fn c5_l14_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -109,13 +98,7 @@ fn c6_l15_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -123,13 +106,7 @@ fn c7_l16_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -137,13 +114,7 @@ fn c8_l17_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -151,13 +122,7 @@ fn c9_l18_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -165,13 +130,7 @@ fn c10_l19_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -179,13 +138,7 @@ fn c11_l20_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -257,10 +210,7 @@ fn c20_l29_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -268,10 +218,7 @@ fn c21_l30_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -279,10 +226,7 @@ fn c22_l31_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -290,10 +234,7 @@ fn c23_l32_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -301,13 +242,7 @@ fn c24_l33_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -315,13 +250,7 @@ fn c25_l34_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -329,13 +258,7 @@ fn c26_l35_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -343,13 +266,7 @@ fn c27_l36_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -357,10 +274,7 @@ fn c28_l37_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -368,10 +282,7 @@ fn c29_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -379,10 +290,7 @@ fn c30_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -390,10 +298,7 @@ fn c31_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -401,13 +306,7 @@ fn c32_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -415,13 +314,7 @@ fn c33_l42_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -429,10 +322,7 @@ fn c34_l43_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -440,10 +330,7 @@ fn c35_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -451,1368 +338,576 @@ fn c36_l45_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -1851,13 +946,7 @@ fn c112_l121_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -1865,13 +954,7 @@ fn c113_l122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -1879,13 +962,7 @@ fn c114_l123_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -1893,13 +970,7 @@ fn c115_l124_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -1907,13 +978,7 @@ fn c116_l125_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -1921,13 +986,7 @@ fn c117_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -1935,13 +994,7 @@ fn c118_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -1949,13 +1002,7 @@ fn c119_l128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2027,10 +1074,7 @@ fn c128_l137_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2038,10 +1082,7 @@ fn c129_l138_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2049,10 +1090,7 @@ fn c130_l139_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2060,10 +1098,7 @@ fn c131_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2071,13 +1106,7 @@ fn c132_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2085,13 +1114,7 @@ fn c133_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2099,13 +1122,7 @@ fn c134_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2113,13 +1130,7 @@ fn c135_l144_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2127,10 +1138,7 @@ fn c136_l145_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2138,10 +1146,7 @@ fn c137_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2149,10 +1154,7 @@ fn c138_l147_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2160,10 +1162,7 @@ fn c139_l148_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2171,13 +1170,7 @@ fn c140_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2185,13 +1178,7 @@ fn c141_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2199,10 +1186,7 @@ fn c142_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.5f32)))));
     result.map(|_| ())
 }
@@ -2210,10 +1194,7 @@ fn c143_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32((0.5f32)))));
     result.map(|_| ())
 }
@@ -2253,13 +1234,7 @@ fn c148_l157_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2267,13 +1242,7 @@ fn c149_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2281,13 +1250,7 @@ fn c150_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2295,13 +1258,7 @@ fn c151_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2309,13 +1266,7 @@ fn c152_l161_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2323,13 +1274,7 @@ fn c153_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2337,13 +1282,7 @@ fn c154_l163_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2351,13 +1290,7 @@ fn c155_l164_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2429,10 +1362,7 @@ fn c164_l173_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2440,10 +1370,7 @@ fn c165_l174_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2451,10 +1378,7 @@ fn c166_l175_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2462,10 +1386,7 @@ fn c167_l176_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2473,13 +1394,7 @@ fn c168_l177_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2487,13 +1402,7 @@ fn c169_l178_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2501,13 +1410,7 @@ fn c170_l179_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2515,13 +1418,7 @@ fn c171_l180_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2529,10 +1426,7 @@ fn c172_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2540,10 +1434,7 @@ fn c173_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2551,10 +1442,7 @@ fn c174_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2562,10 +1450,7 @@ fn c175_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2573,13 +1458,7 @@ fn c176_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2587,13 +1466,7 @@ fn c177_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2601,10 +1474,7 @@ fn c178_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -2612,10 +1482,7 @@ fn c179_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2623,10 +1490,7 @@ fn c180_l189_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2634,10 +1498,7 @@ fn c181_l190_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2645,10 +1506,7 @@ fn c182_l191_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2656,10 +1514,7 @@ fn c183_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2667,13 +1522,7 @@ fn c184_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2681,13 +1530,7 @@ fn c185_l194_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2695,13 +1538,7 @@ fn c186_l195_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2709,13 +1546,7 @@ fn c187_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2723,13 +1554,7 @@ fn c188_l197_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2737,13 +1562,7 @@ fn c189_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2751,13 +1570,7 @@ fn c190_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2765,13 +1578,7 @@ fn c191_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2779,10 +1586,7 @@ fn c192_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2790,10 +1594,7 @@ fn c193_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2801,10 +1602,7 @@ fn c194_l203_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2812,10 +1610,7 @@ fn c195_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2823,10 +1618,7 @@ fn c196_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2834,10 +1626,7 @@ fn c197_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2845,10 +1634,7 @@ fn c198_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2856,10 +1642,7 @@ fn c199_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2867,10 +1650,7 @@ fn c200_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2878,10 +1658,7 @@ fn c201_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2889,10 +1666,7 @@ fn c202_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2900,10 +1674,7 @@ fn c203_l212_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2911,13 +1682,7 @@ fn c204_l213_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2925,13 +1690,7 @@ fn c205_l214_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2939,13 +1698,7 @@ fn c206_l215_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2953,13 +1706,7 @@ fn c207_l216_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2967,10 +1714,7 @@ fn c208_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2978,10 +1722,7 @@ fn c209_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -2989,10 +1730,7 @@ fn c210_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3000,10 +1738,7 @@ fn c211_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3011,13 +1746,7 @@ fn c212_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3025,13 +1754,7 @@ fn c213_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3039,13 +1762,7 @@ fn c214_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3053,13 +1770,7 @@ fn c215_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32((6.2831855f32)))));
     result.map(|_| ())
 }
@@ -3067,694 +1778,295 @@ fn c216_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.5f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3762,10 +2074,7 @@ fn c253_l262_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3773,10 +2082,7 @@ fn c254_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3784,10 +2090,7 @@ fn c255_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3795,13 +2098,7 @@ fn c256_l265_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3809,13 +2106,7 @@ fn c257_l266_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3823,13 +2114,7 @@ fn c258_l267_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3837,13 +2122,7 @@ fn c259_l268_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3851,13 +2130,7 @@ fn c260_l269_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3865,13 +2138,7 @@ fn c261_l270_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3879,13 +2146,7 @@ fn c262_l271_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3893,13 +2154,7 @@ fn c263_l272_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3907,10 +2162,7 @@ fn c264_l273_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3918,10 +2170,7 @@ fn c265_l274_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3929,10 +2178,7 @@ fn c266_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3940,10 +2186,7 @@ fn c267_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3951,10 +2194,7 @@ fn c268_l277_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3962,10 +2202,7 @@ fn c269_l278_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3973,10 +2210,7 @@ fn c270_l279_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3984,10 +2218,7 @@ fn c271_l280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3995,10 +2226,7 @@ fn c272_l281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4006,10 +2234,7 @@ fn c273_l282_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4017,10 +2242,7 @@ fn c274_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4028,10 +2250,7 @@ fn c275_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4039,13 +2258,7 @@ fn c276_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4053,13 +2266,7 @@ fn c277_l286_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4067,13 +2274,7 @@ fn c278_l287_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4081,13 +2282,7 @@ fn c279_l288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4095,10 +2290,7 @@ fn c280_l289_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4106,10 +2298,7 @@ fn c281_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4117,10 +2306,7 @@ fn c282_l291_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4128,10 +2314,7 @@ fn c283_l292_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4139,13 +2322,7 @@ fn c284_l293_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4153,13 +2330,7 @@ fn c285_l294_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4167,13 +2338,7 @@ fn c286_l295_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -4181,13 +2346,7 @@ fn c287_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -4195,810 +2354,504 @@ fn c288_l297_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     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);
-    }
+                                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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     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);
-    }
+                                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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     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);
-    }
+                                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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     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);
-    }
+                                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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]);
     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);
-    }
+                                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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]);
     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);
-    }
+                                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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]);
     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);
-    }
+                                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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]);
     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);
-    }
+                                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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]);
     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);
-    }
+                                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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]);
     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);
-    }
+                                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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     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);
-    }
+                                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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     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);
-    }
+                                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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     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);
-    }
+                                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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     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);
-    }
+                                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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]);
     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);
-    }
+                                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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]);
     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);
-    }
+                                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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]);
     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);
-    }
+                                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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]);
     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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -5021,72 +2874,32 @@ fn c326_l335_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("abs", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("abs", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("abs", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("abs", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -5141,32 +2954,16 @@ fn c336_l345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("abs", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("abs", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -5191,15 +2988,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -5208,15 +3002,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -5239,72 +3030,32 @@ fn c344_l353_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("neg", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("neg", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("neg", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("neg", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -5359,32 +3110,16 @@ fn c354_l363_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("neg", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("neg", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -5409,15 +3144,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -5426,15 +3158,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
diff --git a/lib/runtime/tests/spectests/f32_cmp.rs b/lib/runtime/tests/spectests/f32_cmp.rs
index e08b699f4..13628bf14 100644
--- a/lib/runtime/tests/spectests/f32_cmp.rs
+++ b/lib/runtime/tests/spectests/f32_cmp.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 4
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result i32)))
       (func (;0;) (type 0) (param f32 f32) (result i32)
@@ -50,11 +54,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -97,13 +98,7 @@ fn c4_l16_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -111,13 +106,7 @@ fn c5_l17_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -125,13 +114,7 @@ fn c6_l18_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -139,13 +122,7 @@ fn c7_l19_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -153,13 +130,7 @@ fn c8_l20_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -167,13 +138,7 @@ fn c9_l21_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -181,13 +146,7 @@ fn c10_l22_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -195,13 +154,7 @@ fn c11_l23_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -305,13 +258,7 @@ fn c24_l36_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -319,13 +266,7 @@ fn c25_l37_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -333,13 +274,7 @@ fn c26_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -347,13 +282,7 @@ fn c27_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -361,10 +290,7 @@ fn c28_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -396,13 +322,7 @@ fn c32_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -410,13 +330,7 @@ fn c33_l45_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -424,13 +338,7 @@ fn c34_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -438,13 +346,7 @@ fn c35_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -452,10 +354,7 @@ fn c36_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -463,10 +362,7 @@ fn c37_l49_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -474,10 +370,7 @@ fn c38_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -485,10 +378,7 @@ fn c39_l51_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -496,13 +386,7 @@ fn c40_l52_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -510,13 +394,7 @@ fn c41_l53_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -524,13 +402,7 @@ fn c42_l54_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -538,13 +410,7 @@ fn c43_l55_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -552,13 +418,7 @@ fn c44_l56_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -566,13 +426,7 @@ fn c45_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -580,13 +434,7 @@ fn c46_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -594,13 +442,7 @@ fn c47_l59_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -608,13 +450,7 @@ fn c48_l60_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -622,13 +458,7 @@ fn c49_l61_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -636,13 +466,7 @@ fn c50_l62_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -650,13 +474,7 @@ fn c51_l63_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -664,13 +482,7 @@ fn c52_l64_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -678,13 +490,7 @@ fn c53_l65_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -692,13 +498,7 @@ fn c54_l66_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -706,13 +506,7 @@ fn c55_l67_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -720,13 +514,7 @@ fn c56_l68_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -734,13 +522,7 @@ fn c57_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -748,13 +530,7 @@ fn c58_l70_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -762,13 +538,7 @@ fn c59_l71_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -776,13 +546,7 @@ fn c60_l72_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -790,13 +554,7 @@ fn c61_l73_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -804,13 +562,7 @@ fn c62_l74_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -818,13 +570,7 @@ fn c63_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -832,13 +578,7 @@ fn c64_l76_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -846,13 +586,7 @@ fn c65_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -860,13 +594,7 @@ fn c66_l78_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -874,13 +602,7 @@ fn c67_l79_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -888,13 +610,7 @@ fn c68_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -902,13 +618,7 @@ fn c69_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -916,13 +626,7 @@ fn c70_l82_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -930,13 +634,7 @@ fn c71_l83_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -944,13 +642,7 @@ fn c72_l84_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -958,13 +650,7 @@ fn c73_l85_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -972,13 +658,7 @@ fn c74_l86_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -986,13 +666,7 @@ fn c75_l87_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1000,13 +674,7 @@ fn c76_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1014,13 +682,7 @@ fn c77_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1028,13 +690,7 @@ fn c78_l90_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1042,13 +698,7 @@ fn c79_l91_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1056,13 +706,7 @@ fn c80_l92_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1070,13 +714,7 @@ fn c81_l93_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1084,13 +722,7 @@ fn c82_l94_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1098,13 +730,7 @@ fn c83_l95_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1112,13 +738,7 @@ fn c84_l96_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1126,13 +746,7 @@ fn c85_l97_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1140,13 +754,7 @@ fn c86_l98_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1154,13 +762,7 @@ fn c87_l99_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1168,13 +770,7 @@ fn c88_l100_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -1182,13 +778,7 @@ fn c89_l101_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1196,13 +786,7 @@ fn c90_l102_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1210,13 +794,7 @@ fn c91_l103_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -1224,13 +802,7 @@ fn c92_l104_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1238,13 +810,7 @@ fn c93_l105_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1252,13 +818,7 @@ fn c94_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1266,13 +826,7 @@ fn c95_l107_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1280,13 +834,7 @@ fn c96_l108_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1294,13 +842,7 @@ fn c97_l109_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1308,13 +850,7 @@ fn c98_l110_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1322,13 +858,7 @@ fn c99_l111_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1336,13 +866,7 @@ fn c100_l112_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1350,13 +874,7 @@ fn c101_l113_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1364,13 +882,7 @@ fn c102_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1378,13 +890,7 @@ fn c103_l115_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1392,13 +898,7 @@ fn c104_l116_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1406,13 +906,7 @@ fn c105_l117_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1420,13 +914,7 @@ fn c106_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1434,13 +922,7 @@ fn c107_l119_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1448,13 +930,7 @@ fn c108_l120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1462,13 +938,7 @@ fn c109_l121_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1476,13 +946,7 @@ fn c110_l122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1490,13 +954,7 @@ fn c111_l123_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1504,13 +962,7 @@ fn c112_l124_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1518,13 +970,7 @@ fn c113_l125_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1532,13 +978,7 @@ fn c114_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1546,13 +986,7 @@ fn c115_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1560,13 +994,7 @@ fn c116_l128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1574,13 +1002,7 @@ fn c117_l129_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1588,13 +1010,7 @@ fn c118_l130_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1602,13 +1018,7 @@ fn c119_l131_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1648,13 +1058,7 @@ fn c124_l136_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1662,13 +1066,7 @@ fn c125_l137_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1676,13 +1074,7 @@ fn c126_l138_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1690,13 +1082,7 @@ fn c127_l139_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1704,13 +1090,7 @@ fn c128_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1718,13 +1098,7 @@ fn c129_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1732,13 +1106,7 @@ fn c130_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1746,13 +1114,7 @@ fn c131_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1856,13 +1218,7 @@ fn c144_l156_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1870,13 +1226,7 @@ fn c145_l157_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1884,13 +1234,7 @@ fn c146_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1898,13 +1242,7 @@ fn c147_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1912,10 +1250,7 @@ fn c148_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1947,13 +1282,7 @@ fn c152_l164_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1961,13 +1290,7 @@ fn c153_l165_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1975,13 +1298,7 @@ fn c154_l166_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1989,13 +1306,7 @@ fn c155_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2003,10 +1314,7 @@ fn c156_l168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2014,10 +1322,7 @@ fn c157_l169_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2025,10 +1330,7 @@ fn c158_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2036,10 +1338,7 @@ fn c159_l171_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2079,13 +1378,7 @@ fn c164_l176_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2093,13 +1386,7 @@ fn c165_l177_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2107,13 +1394,7 @@ fn c166_l178_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2121,13 +1402,7 @@ fn c167_l179_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2135,13 +1410,7 @@ fn c168_l180_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2149,13 +1418,7 @@ fn c169_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2163,13 +1426,7 @@ fn c170_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2177,13 +1434,7 @@ fn c171_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2287,13 +1538,7 @@ fn c184_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2301,13 +1546,7 @@ fn c185_l197_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2315,13 +1554,7 @@ fn c186_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2329,13 +1562,7 @@ fn c187_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2343,10 +1570,7 @@ fn c188_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2378,13 +1602,7 @@ fn c192_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2392,13 +1610,7 @@ fn c193_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2406,13 +1618,7 @@ fn c194_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2420,13 +1626,7 @@ fn c195_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2434,10 +1634,7 @@ fn c196_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2445,10 +1642,7 @@ fn c197_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2456,10 +1650,7 @@ fn c198_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2467,10 +1658,7 @@ fn c199_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2510,13 +1698,7 @@ fn c204_l216_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2524,13 +1706,7 @@ fn c205_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2538,13 +1714,7 @@ fn c206_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2552,13 +1722,7 @@ fn c207_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2566,13 +1730,7 @@ fn c208_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2580,13 +1738,7 @@ fn c209_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2594,13 +1746,7 @@ fn c210_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2608,13 +1754,7 @@ fn c211_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2686,10 +1826,7 @@ fn c220_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -2697,10 +1834,7 @@ fn c221_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2708,10 +1842,7 @@ fn c222_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2719,10 +1850,7 @@ fn c223_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -2730,13 +1858,7 @@ fn c224_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2744,13 +1866,7 @@ fn c225_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2758,13 +1874,7 @@ fn c226_l238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2772,13 +1882,7 @@ fn c227_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2786,10 +1890,7 @@ fn c228_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2797,10 +1898,7 @@ fn c229_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2808,10 +1906,7 @@ fn c230_l242_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2819,10 +1914,7 @@ fn c231_l243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2830,13 +1922,7 @@ fn c232_l244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2844,13 +1930,7 @@ fn c233_l245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2858,13 +1938,7 @@ fn c234_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2872,13 +1946,7 @@ fn c235_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2886,13 +1954,7 @@ fn c236_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2900,13 +1962,7 @@ fn c237_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2914,13 +1970,7 @@ fn c238_l250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2928,13 +1978,7 @@ fn c239_l251_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2942,13 +1986,7 @@ fn c240_l252_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2956,13 +1994,7 @@ fn c241_l253_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2970,13 +2002,7 @@ fn c242_l254_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2984,13 +2010,7 @@ fn c243_l255_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2998,13 +2018,7 @@ fn c244_l256_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3012,13 +2026,7 @@ fn c245_l257_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3026,13 +2034,7 @@ fn c246_l258_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3040,13 +2042,7 @@ fn c247_l259_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3054,13 +2050,7 @@ fn c248_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3068,13 +2058,7 @@ fn c249_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3082,13 +2066,7 @@ fn c250_l262_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3096,13 +2074,7 @@ fn c251_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3110,13 +2082,7 @@ fn c252_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3124,13 +2090,7 @@ fn c253_l265_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3138,13 +2098,7 @@ fn c254_l266_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3152,13 +2106,7 @@ fn c255_l267_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3166,13 +2114,7 @@ fn c256_l268_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3180,13 +2122,7 @@ fn c257_l269_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3194,13 +2130,7 @@ fn c258_l270_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3208,13 +2138,7 @@ fn c259_l271_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3222,13 +2146,7 @@ fn c260_l272_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3236,13 +2154,7 @@ fn c261_l273_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3250,13 +2162,7 @@ fn c262_l274_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3264,13 +2170,7 @@ fn c263_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3278,13 +2178,7 @@ fn c264_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -3292,13 +2186,7 @@ fn c265_l277_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3306,13 +2194,7 @@ fn c266_l278_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3320,13 +2202,7 @@ fn c267_l279_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -3334,13 +2210,7 @@ fn c268_l280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3348,13 +2218,7 @@ fn c269_l281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3362,13 +2226,7 @@ fn c270_l282_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3376,13 +2234,7 @@ fn c271_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3390,13 +2242,7 @@ fn c272_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3404,13 +2250,7 @@ fn c273_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3418,13 +2258,7 @@ fn c274_l286_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3432,13 +2266,7 @@ fn c275_l287_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3446,13 +2274,7 @@ fn c276_l288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3460,13 +2282,7 @@ fn c277_l289_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3474,13 +2290,7 @@ fn c278_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3488,13 +2298,7 @@ fn c279_l291_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3502,10 +2306,7 @@ fn c280_l292_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3537,13 +2338,7 @@ fn c284_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3551,13 +2346,7 @@ fn c285_l297_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3565,13 +2354,7 @@ fn c286_l298_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3579,13 +2362,7 @@ fn c287_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3593,13 +2370,7 @@ fn c288_l300_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3607,13 +2378,7 @@ fn c289_l301_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3621,13 +2386,7 @@ fn c290_l302_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3635,13 +2394,7 @@ fn c291_l303_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3649,10 +2402,7 @@ fn c292_l304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3684,10 +2434,7 @@ fn c296_l308_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3719,10 +2466,7 @@ fn c300_l312_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3730,10 +2474,7 @@ fn c301_l313_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3741,10 +2482,7 @@ fn c302_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3752,10 +2490,7 @@ fn c303_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3763,13 +2498,7 @@ fn c304_l316_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3777,13 +2506,7 @@ fn c305_l317_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3791,13 +2514,7 @@ fn c306_l318_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3805,13 +2522,7 @@ fn c307_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3819,10 +2530,7 @@ fn c308_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -3830,10 +2538,7 @@ fn c309_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3841,10 +2546,7 @@ fn c310_l322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3852,10 +2554,7 @@ fn c311_l323_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -3863,13 +2562,7 @@ fn c312_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3877,13 +2570,7 @@ fn c313_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3891,13 +2578,7 @@ fn c314_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3905,13 +2586,7 @@ fn c315_l327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3919,13 +2594,7 @@ fn c316_l328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3933,13 +2602,7 @@ fn c317_l329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3947,13 +2610,7 @@ fn c318_l330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3961,13 +2618,7 @@ fn c319_l331_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3975,13 +2626,7 @@ fn c320_l332_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3989,13 +2634,7 @@ fn c321_l333_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4003,10 +2642,7 @@ fn c322_l334_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4014,10 +2650,7 @@ fn c323_l335_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4025,13 +2658,7 @@ fn c324_l336_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4039,13 +2666,7 @@ fn c325_l337_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4053,10 +2674,7 @@ fn c326_l338_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4064,10 +2682,7 @@ fn c327_l339_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4075,13 +2690,7 @@ fn c328_l340_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4089,13 +2698,7 @@ fn c329_l341_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4103,13 +2706,7 @@ fn c330_l342_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4117,13 +2714,7 @@ fn c331_l343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4131,13 +2722,7 @@ fn c332_l344_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4145,13 +2730,7 @@ fn c333_l345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4159,13 +2738,7 @@ fn c334_l346_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4173,13 +2746,7 @@ fn c335_l347_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4187,13 +2754,7 @@ fn c336_l348_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4201,13 +2762,7 @@ fn c337_l349_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4215,13 +2770,7 @@ fn c338_l350_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4229,13 +2778,7 @@ fn c339_l351_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4243,13 +2786,7 @@ fn c340_l352_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4257,13 +2794,7 @@ fn c341_l353_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4271,13 +2802,7 @@ fn c342_l354_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4285,13 +2810,7 @@ fn c343_l355_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4299,13 +2818,7 @@ fn c344_l356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4313,13 +2826,7 @@ fn c345_l357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4327,10 +2834,7 @@ fn c346_l358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4338,10 +2842,7 @@ fn c347_l359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4349,13 +2850,7 @@ fn c348_l360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4363,13 +2858,7 @@ fn c349_l361_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4377,10 +2866,7 @@ fn c350_l362_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4388,10 +2874,7 @@ fn c351_l363_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4399,13 +2882,7 @@ fn c352_l364_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4413,13 +2890,7 @@ fn c353_l365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4427,10 +2898,7 @@ fn c354_l366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4438,10 +2906,7 @@ fn c355_l367_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4449,13 +2914,7 @@ fn c356_l368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4463,13 +2922,7 @@ fn c357_l369_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4477,10 +2930,7 @@ fn c358_l370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4488,10 +2938,7 @@ fn c359_l371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4499,13 +2946,7 @@ fn c360_l372_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4513,13 +2954,7 @@ fn c361_l373_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4527,13 +2962,7 @@ fn c362_l374_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4541,13 +2970,7 @@ fn c363_l375_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4555,13 +2978,7 @@ fn c364_l376_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4569,13 +2986,7 @@ fn c365_l377_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4583,13 +2994,7 @@ fn c366_l378_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4597,13 +3002,7 @@ fn c367_l379_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4611,13 +3010,7 @@ fn c368_l380_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4625,13 +3018,7 @@ fn c369_l381_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4639,13 +3026,7 @@ fn c370_l382_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4653,13 +3034,7 @@ fn c371_l383_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4667,13 +3042,7 @@ fn c372_l384_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4681,13 +3050,7 @@ fn c373_l385_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4695,13 +3058,7 @@ fn c374_l386_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4709,13 +3066,7 @@ fn c375_l387_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4723,13 +3074,7 @@ fn c376_l388_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4737,13 +3082,7 @@ fn c377_l389_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4751,13 +3090,7 @@ fn c378_l390_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4765,13 +3098,7 @@ fn c379_l391_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4779,13 +3106,7 @@ fn c380_l392_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4793,13 +3114,7 @@ fn c381_l393_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4807,13 +3122,7 @@ fn c382_l394_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4821,13 +3130,7 @@ fn c383_l395_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4835,13 +3138,7 @@ fn c384_l396_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4849,13 +3146,7 @@ fn c385_l397_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4863,13 +3154,7 @@ fn c386_l398_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4877,13 +3162,7 @@ fn c387_l399_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4891,13 +3170,7 @@ fn c388_l400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4905,13 +3178,7 @@ fn c389_l401_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4919,13 +3186,7 @@ fn c390_l402_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4933,13 +3194,7 @@ fn c391_l403_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4947,13 +3202,7 @@ fn c392_l404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4961,13 +3210,7 @@ fn c393_l405_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4975,13 +3218,7 @@ fn c394_l406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4989,13 +3226,7 @@ fn c395_l407_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -5003,13 +3234,7 @@ fn c396_l408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -5017,13 +3242,7 @@ fn c397_l409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -5031,13 +3250,7 @@ fn c398_l410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -5045,13 +3258,7 @@ fn c399_l411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -5091,13 +3298,7 @@ fn c404_l416_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5105,13 +3306,7 @@ fn c405_l417_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5119,13 +3314,7 @@ fn c406_l418_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5133,13 +3322,7 @@ fn c407_l419_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5147,13 +3330,7 @@ fn c408_l420_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5161,13 +3338,7 @@ fn c409_l421_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5175,13 +3346,7 @@ fn c410_l422_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5189,13 +3354,7 @@ fn c411_l423_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5299,13 +3458,7 @@ fn c424_l436_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5313,13 +3466,7 @@ fn c425_l437_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5327,13 +3474,7 @@ fn c426_l438_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5341,13 +3482,7 @@ fn c427_l439_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5355,10 +3490,7 @@ fn c428_l440_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5390,13 +3522,7 @@ fn c432_l444_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5404,13 +3530,7 @@ fn c433_l445_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5418,13 +3538,7 @@ fn c434_l446_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5432,13 +3546,7 @@ fn c435_l447_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5446,10 +3554,7 @@ fn c436_l448_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5457,10 +3562,7 @@ fn c437_l449_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5468,10 +3570,7 @@ fn c438_l450_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5479,10 +3578,7 @@ fn c439_l451_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5490,13 +3586,7 @@ fn c440_l452_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5504,13 +3594,7 @@ fn c441_l453_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5518,13 +3602,7 @@ fn c442_l454_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5532,13 +3610,7 @@ fn c443_l455_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5546,13 +3618,7 @@ fn c444_l456_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -5560,13 +3626,7 @@ fn c445_l457_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5574,13 +3634,7 @@ fn c446_l458_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5588,13 +3642,7 @@ fn c447_l459_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -5602,13 +3650,7 @@ fn c448_l460_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5616,13 +3658,7 @@ fn c449_l461_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5630,13 +3666,7 @@ fn c450_l462_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5644,13 +3674,7 @@ fn c451_l463_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5658,13 +3682,7 @@ fn c452_l464_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5672,13 +3690,7 @@ fn c453_l465_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5686,13 +3698,7 @@ fn c454_l466_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5700,13 +3706,7 @@ fn c455_l467_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5714,13 +3714,7 @@ fn c456_l468_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5728,13 +3722,7 @@ fn c457_l469_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5742,13 +3730,7 @@ fn c458_l470_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5756,13 +3738,7 @@ fn c459_l471_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5770,13 +3746,7 @@ fn c460_l472_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5784,13 +3754,7 @@ fn c461_l473_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5798,13 +3762,7 @@ fn c462_l474_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5812,13 +3770,7 @@ fn c463_l475_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5826,13 +3778,7 @@ fn c464_l476_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5840,13 +3786,7 @@ fn c465_l477_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5854,13 +3794,7 @@ fn c466_l478_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5868,13 +3802,7 @@ fn c467_l479_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5882,13 +3810,7 @@ fn c468_l480_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5896,13 +3818,7 @@ fn c469_l481_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5910,13 +3826,7 @@ fn c470_l482_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5924,13 +3834,7 @@ fn c471_l483_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5938,13 +3842,7 @@ fn c472_l484_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5952,13 +3850,7 @@ fn c473_l485_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5966,13 +3858,7 @@ fn c474_l486_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5980,13 +3866,7 @@ fn c475_l487_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5994,13 +3874,7 @@ fn c476_l488_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6008,13 +3882,7 @@ fn c477_l489_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6022,13 +3890,7 @@ fn c478_l490_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6036,13 +3898,7 @@ fn c479_l491_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6050,13 +3906,7 @@ fn c480_l492_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6064,13 +3914,7 @@ fn c481_l493_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6078,13 +3922,7 @@ fn c482_l494_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6092,13 +3930,7 @@ fn c483_l495_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6106,13 +3938,7 @@ fn c484_l496_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6120,13 +3946,7 @@ fn c485_l497_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6134,13 +3954,7 @@ fn c486_l498_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6148,13 +3962,7 @@ fn c487_l499_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6162,13 +3970,7 @@ fn c488_l500_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -6176,13 +3978,7 @@ fn c489_l501_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6190,13 +3986,7 @@ fn c490_l502_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6204,13 +3994,7 @@ fn c491_l503_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -6218,13 +4002,7 @@ fn c492_l504_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6232,13 +4010,7 @@ fn c493_l505_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6246,13 +4018,7 @@ fn c494_l506_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6260,13 +4026,7 @@ fn c495_l507_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6274,13 +4034,7 @@ fn c496_l508_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6288,13 +4042,7 @@ fn c497_l509_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6302,13 +4050,7 @@ fn c498_l510_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6316,13 +4058,7 @@ fn c499_l511_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6330,13 +4066,7 @@ fn c500_l512_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6344,13 +4074,7 @@ fn c501_l513_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6358,13 +4082,7 @@ fn c502_l514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6372,13 +4090,7 @@ fn c503_l515_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6386,13 +4098,7 @@ fn c504_l516_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6400,13 +4106,7 @@ fn c505_l517_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6414,13 +4114,7 @@ fn c506_l518_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6428,13 +4122,7 @@ fn c507_l519_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6442,13 +4130,7 @@ fn c508_l520_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6456,13 +4138,7 @@ fn c509_l521_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6470,13 +4146,7 @@ fn c510_l522_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6484,13 +4154,7 @@ fn c511_l523_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6498,13 +4162,7 @@ fn c512_l524_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6512,13 +4170,7 @@ fn c513_l525_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6526,13 +4178,7 @@ fn c514_l526_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6540,13 +4186,7 @@ fn c515_l527_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6554,13 +4194,7 @@ fn c516_l528_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6568,13 +4202,7 @@ fn c517_l529_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6582,13 +4210,7 @@ fn c518_l530_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6596,13 +4218,7 @@ fn c519_l531_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6642,13 +4258,7 @@ fn c524_l536_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6656,13 +4266,7 @@ fn c525_l537_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6670,13 +4274,7 @@ fn c526_l538_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6684,13 +4282,7 @@ fn c527_l539_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6698,13 +4290,7 @@ fn c528_l540_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6712,13 +4298,7 @@ fn c529_l541_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6726,13 +4306,7 @@ fn c530_l542_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6740,13 +4314,7 @@ fn c531_l543_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6850,13 +4418,7 @@ fn c544_l556_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6864,13 +4426,7 @@ fn c545_l557_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6878,13 +4434,7 @@ fn c546_l558_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6892,13 +4442,7 @@ fn c547_l559_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6906,10 +4450,7 @@ fn c548_l560_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6941,13 +4482,7 @@ fn c552_l564_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6955,13 +4490,7 @@ fn c553_l565_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6969,13 +4498,7 @@ fn c554_l566_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6983,13 +4506,7 @@ fn c555_l567_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6997,10 +4514,7 @@ fn c556_l568_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7008,10 +4522,7 @@ fn c557_l569_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7019,10 +4530,7 @@ fn c558_l570_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7030,10 +4538,7 @@ fn c559_l571_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7073,13 +4578,7 @@ fn c564_l576_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7087,13 +4586,7 @@ fn c565_l577_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7101,13 +4594,7 @@ fn c566_l578_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7115,13 +4602,7 @@ fn c567_l579_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7129,13 +4610,7 @@ fn c568_l580_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7143,13 +4618,7 @@ fn c569_l581_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7157,13 +4626,7 @@ fn c570_l582_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7171,13 +4634,7 @@ fn c571_l583_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7281,13 +4738,7 @@ fn c584_l596_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7295,13 +4746,7 @@ fn c585_l597_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7309,13 +4754,7 @@ fn c586_l598_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7323,13 +4762,7 @@ fn c587_l599_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7337,10 +4770,7 @@ fn c588_l600_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7372,13 +4802,7 @@ fn c592_l604_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7386,13 +4810,7 @@ fn c593_l605_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7400,13 +4818,7 @@ fn c594_l606_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7414,13 +4826,7 @@ fn c595_l607_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7428,10 +4834,7 @@ fn c596_l608_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7439,10 +4842,7 @@ fn c597_l609_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7450,10 +4850,7 @@ fn c598_l610_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7461,10 +4858,7 @@ fn c599_l611_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7504,13 +4898,7 @@ fn c604_l616_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7518,13 +4906,7 @@ fn c605_l617_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7532,13 +4914,7 @@ fn c606_l618_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7546,13 +4922,7 @@ fn c607_l619_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7560,13 +4930,7 @@ fn c608_l620_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7574,13 +4938,7 @@ fn c609_l621_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7588,13 +4946,7 @@ fn c610_l622_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7602,13 +4954,7 @@ fn c611_l623_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7680,10 +5026,7 @@ fn c620_l632_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -7691,10 +5034,7 @@ fn c621_l633_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7702,10 +5042,7 @@ fn c622_l634_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7713,10 +5050,7 @@ fn c623_l635_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -7724,13 +5058,7 @@ fn c624_l636_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7738,13 +5066,7 @@ fn c625_l637_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7752,13 +5074,7 @@ fn c626_l638_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7766,13 +5082,7 @@ fn c627_l639_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7780,10 +5090,7 @@ fn c628_l640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7791,10 +5098,7 @@ fn c629_l641_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7802,10 +5106,7 @@ fn c630_l642_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7813,10 +5114,7 @@ fn c631_l643_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7824,13 +5122,7 @@ fn c632_l644_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7838,13 +5130,7 @@ fn c633_l645_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7852,13 +5138,7 @@ fn c634_l646_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7866,13 +5146,7 @@ fn c635_l647_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7880,13 +5154,7 @@ fn c636_l648_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7894,13 +5162,7 @@ fn c637_l649_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7908,13 +5170,7 @@ fn c638_l650_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7922,13 +5178,7 @@ fn c639_l651_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7936,13 +5186,7 @@ fn c640_l652_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7950,13 +5194,7 @@ fn c641_l653_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7964,13 +5202,7 @@ fn c642_l654_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7978,13 +5210,7 @@ fn c643_l655_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7992,13 +5218,7 @@ fn c644_l656_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8006,13 +5226,7 @@ fn c645_l657_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8020,13 +5234,7 @@ fn c646_l658_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8034,13 +5242,7 @@ fn c647_l659_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8048,13 +5250,7 @@ fn c648_l660_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8062,13 +5258,7 @@ fn c649_l661_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8076,13 +5266,7 @@ fn c650_l662_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8090,13 +5274,7 @@ fn c651_l663_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8104,13 +5282,7 @@ fn c652_l664_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8118,13 +5290,7 @@ fn c653_l665_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8132,13 +5298,7 @@ fn c654_l666_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8146,13 +5306,7 @@ fn c655_l667_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8160,13 +5314,7 @@ fn c656_l668_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8174,13 +5322,7 @@ fn c657_l669_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8188,13 +5330,7 @@ fn c658_l670_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8202,13 +5338,7 @@ fn c659_l671_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8216,13 +5346,7 @@ fn c660_l672_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8230,13 +5354,7 @@ fn c661_l673_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8244,13 +5362,7 @@ fn c662_l674_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8258,13 +5370,7 @@ fn c663_l675_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8272,13 +5378,7 @@ fn c664_l676_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8286,13 +5386,7 @@ fn c665_l677_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8300,13 +5394,7 @@ fn c666_l678_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8314,13 +5402,7 @@ fn c667_l679_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8328,13 +5410,7 @@ fn c668_l680_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8342,13 +5418,7 @@ fn c669_l681_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8356,13 +5426,7 @@ fn c670_l682_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8370,13 +5434,7 @@ fn c671_l683_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8384,13 +5442,7 @@ fn c672_l684_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8398,13 +5450,7 @@ fn c673_l685_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8412,13 +5458,7 @@ fn c674_l686_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8426,13 +5466,7 @@ fn c675_l687_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8440,13 +5474,7 @@ fn c676_l688_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8454,13 +5482,7 @@ fn c677_l689_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8468,13 +5490,7 @@ fn c678_l690_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8482,13 +5498,7 @@ fn c679_l691_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8496,10 +5506,7 @@ fn c680_l692_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8531,13 +5538,7 @@ fn c684_l696_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8545,13 +5546,7 @@ fn c685_l697_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8559,13 +5554,7 @@ fn c686_l698_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8573,13 +5562,7 @@ fn c687_l699_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8587,13 +5570,7 @@ fn c688_l700_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8601,13 +5578,7 @@ fn c689_l701_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8615,13 +5586,7 @@ fn c690_l702_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8629,13 +5594,7 @@ fn c691_l703_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8643,10 +5602,7 @@ fn c692_l704_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8678,10 +5634,7 @@ fn c696_l708_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8713,10 +5666,7 @@ fn c700_l712_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8724,10 +5674,7 @@ fn c701_l713_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8735,10 +5682,7 @@ fn c702_l714_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8746,10 +5690,7 @@ fn c703_l715_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8757,13 +5698,7 @@ fn c704_l716_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8771,13 +5706,7 @@ fn c705_l717_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8785,13 +5714,7 @@ fn c706_l718_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8799,13 +5722,7 @@ fn c707_l719_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8813,10 +5730,7 @@ fn c708_l720_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8824,10 +5738,7 @@ fn c709_l721_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8835,10 +5746,7 @@ fn c710_l722_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8846,10 +5754,7 @@ fn c711_l723_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8857,13 +5762,7 @@ fn c712_l724_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8871,13 +5770,7 @@ fn c713_l725_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8885,13 +5778,7 @@ fn c714_l726_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8899,13 +5786,7 @@ fn c715_l727_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8913,13 +5794,7 @@ fn c716_l728_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8927,13 +5802,7 @@ fn c717_l729_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8941,13 +5810,7 @@ fn c718_l730_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8955,13 +5818,7 @@ fn c719_l731_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8969,13 +5826,7 @@ fn c720_l732_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8983,13 +5834,7 @@ fn c721_l733_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8997,10 +5842,7 @@ fn c722_l734_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9008,10 +5850,7 @@ fn c723_l735_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9019,13 +5858,7 @@ fn c724_l736_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9033,13 +5866,7 @@ fn c725_l737_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9047,10 +5874,7 @@ fn c726_l738_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9058,10 +5882,7 @@ fn c727_l739_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9069,13 +5890,7 @@ fn c728_l740_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9083,13 +5898,7 @@ fn c729_l741_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9097,13 +5906,7 @@ fn c730_l742_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9111,13 +5914,7 @@ fn c731_l743_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9125,13 +5922,7 @@ fn c732_l744_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9139,13 +5930,7 @@ fn c733_l745_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9153,13 +5938,7 @@ fn c734_l746_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9167,13 +5946,7 @@ fn c735_l747_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9181,13 +5954,7 @@ fn c736_l748_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9195,13 +5962,7 @@ fn c737_l749_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9209,13 +5970,7 @@ fn c738_l750_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9223,13 +5978,7 @@ fn c739_l751_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9237,13 +5986,7 @@ fn c740_l752_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9251,13 +5994,7 @@ fn c741_l753_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9265,13 +6002,7 @@ fn c742_l754_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9279,13 +6010,7 @@ fn c743_l755_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9293,13 +6018,7 @@ fn c744_l756_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9307,13 +6026,7 @@ fn c745_l757_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9321,10 +6034,7 @@ fn c746_l758_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9332,10 +6042,7 @@ fn c747_l759_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9343,13 +6050,7 @@ fn c748_l760_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9357,13 +6058,7 @@ fn c749_l761_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9371,10 +6066,7 @@ fn c750_l762_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9382,10 +6074,7 @@ fn c751_l763_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9393,13 +6082,7 @@ fn c752_l764_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9407,13 +6090,7 @@ fn c753_l765_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9421,10 +6098,7 @@ fn c754_l766_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9432,10 +6106,7 @@ fn c755_l767_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9443,13 +6114,7 @@ fn c756_l768_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9457,13 +6122,7 @@ fn c757_l769_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9471,10 +6130,7 @@ fn c758_l770_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9482,10 +6138,7 @@ fn c759_l771_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9493,13 +6146,7 @@ fn c760_l772_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9507,13 +6154,7 @@ fn c761_l773_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9521,13 +6162,7 @@ fn c762_l774_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9535,13 +6170,7 @@ fn c763_l775_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9549,13 +6178,7 @@ fn c764_l776_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9563,13 +6186,7 @@ fn c765_l777_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9577,13 +6194,7 @@ fn c766_l778_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9591,13 +6202,7 @@ fn c767_l779_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9605,13 +6210,7 @@ fn c768_l780_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9619,13 +6218,7 @@ fn c769_l781_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9633,13 +6226,7 @@ fn c770_l782_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9647,13 +6234,7 @@ fn c771_l783_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9661,13 +6242,7 @@ fn c772_l784_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9675,13 +6250,7 @@ fn c773_l785_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9689,13 +6258,7 @@ fn c774_l786_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9703,13 +6266,7 @@ fn c775_l787_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9717,13 +6274,7 @@ fn c776_l788_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9731,13 +6282,7 @@ fn c777_l789_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9745,13 +6290,7 @@ fn c778_l790_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9759,13 +6298,7 @@ fn c779_l791_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9773,13 +6306,7 @@ fn c780_l792_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9787,13 +6314,7 @@ fn c781_l793_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9801,13 +6322,7 @@ fn c782_l794_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9815,13 +6330,7 @@ fn c783_l795_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9829,13 +6338,7 @@ fn c784_l796_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9843,13 +6346,7 @@ fn c785_l797_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9857,13 +6354,7 @@ fn c786_l798_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9871,13 +6362,7 @@ fn c787_l799_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9885,13 +6370,7 @@ fn c788_l800_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9899,13 +6378,7 @@ fn c789_l801_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9913,13 +6386,7 @@ fn c790_l802_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9927,13 +6394,7 @@ fn c791_l803_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9941,13 +6402,7 @@ fn c792_l804_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9955,13 +6410,7 @@ fn c793_l805_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9969,13 +6418,7 @@ fn c794_l806_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9983,13 +6426,7 @@ fn c795_l807_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9997,13 +6434,7 @@ fn c796_l808_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10011,13 +6442,7 @@ fn c797_l809_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10025,13 +6450,7 @@ fn c798_l810_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10039,13 +6458,7 @@ fn c799_l811_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10085,13 +6498,7 @@ fn c804_l816_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10099,13 +6506,7 @@ fn c805_l817_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10113,13 +6514,7 @@ fn c806_l818_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10127,13 +6522,7 @@ fn c807_l819_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10141,13 +6530,7 @@ fn c808_l820_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10155,13 +6538,7 @@ fn c809_l821_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10169,13 +6546,7 @@ fn c810_l822_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10183,13 +6554,7 @@ fn c811_l823_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10293,13 +6658,7 @@ fn c824_l836_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10307,13 +6666,7 @@ fn c825_l837_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10321,13 +6674,7 @@ fn c826_l838_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10335,13 +6682,7 @@ fn c827_l839_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10349,10 +6690,7 @@ fn c828_l840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10384,13 +6722,7 @@ fn c832_l844_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10398,13 +6730,7 @@ fn c833_l845_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10412,13 +6738,7 @@ fn c834_l846_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10426,13 +6746,7 @@ fn c835_l847_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10440,10 +6754,7 @@ fn c836_l848_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10451,10 +6762,7 @@ fn c837_l849_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10462,10 +6770,7 @@ fn c838_l850_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10473,10 +6778,7 @@ fn c839_l851_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10484,13 +6786,7 @@ fn c840_l852_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10498,13 +6794,7 @@ fn c841_l853_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10512,13 +6802,7 @@ fn c842_l854_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10526,13 +6810,7 @@ fn c843_l855_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10540,13 +6818,7 @@ fn c844_l856_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10554,13 +6826,7 @@ fn c845_l857_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10568,13 +6834,7 @@ fn c846_l858_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10582,13 +6842,7 @@ fn c847_l859_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10596,13 +6850,7 @@ fn c848_l860_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10610,13 +6858,7 @@ fn c849_l861_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10624,13 +6866,7 @@ fn c850_l862_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10638,13 +6874,7 @@ fn c851_l863_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10652,13 +6882,7 @@ fn c852_l864_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10666,13 +6890,7 @@ fn c853_l865_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10680,13 +6898,7 @@ fn c854_l866_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10694,13 +6906,7 @@ fn c855_l867_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10708,13 +6914,7 @@ fn c856_l868_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10722,13 +6922,7 @@ fn c857_l869_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10736,13 +6930,7 @@ fn c858_l870_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10750,13 +6938,7 @@ fn c859_l871_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10764,13 +6946,7 @@ fn c860_l872_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10778,13 +6954,7 @@ fn c861_l873_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10792,13 +6962,7 @@ fn c862_l874_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10806,13 +6970,7 @@ fn c863_l875_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10820,13 +6978,7 @@ fn c864_l876_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10834,13 +6986,7 @@ fn c865_l877_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10848,13 +6994,7 @@ fn c866_l878_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10862,13 +7002,7 @@ fn c867_l879_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10876,13 +7010,7 @@ fn c868_l880_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10890,13 +7018,7 @@ fn c869_l881_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10904,13 +7026,7 @@ fn c870_l882_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10918,13 +7034,7 @@ fn c871_l883_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10932,13 +7042,7 @@ fn c872_l884_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10946,13 +7050,7 @@ fn c873_l885_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10960,13 +7058,7 @@ fn c874_l886_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10974,13 +7066,7 @@ fn c875_l887_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10988,13 +7074,7 @@ fn c876_l888_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11002,13 +7082,7 @@ fn c877_l889_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11016,13 +7090,7 @@ fn c878_l890_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11030,13 +7098,7 @@ fn c879_l891_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11044,13 +7106,7 @@ fn c880_l892_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11058,13 +7114,7 @@ fn c881_l893_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11072,13 +7122,7 @@ fn c882_l894_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11086,13 +7130,7 @@ fn c883_l895_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11100,13 +7138,7 @@ fn c884_l896_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11114,13 +7146,7 @@ fn c885_l897_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11128,13 +7154,7 @@ fn c886_l898_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11142,13 +7162,7 @@ fn c887_l899_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11156,13 +7170,7 @@ fn c888_l900_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11170,13 +7178,7 @@ fn c889_l901_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11184,13 +7186,7 @@ fn c890_l902_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11198,13 +7194,7 @@ fn c891_l903_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11212,13 +7202,7 @@ fn c892_l904_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11226,13 +7210,7 @@ fn c893_l905_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11240,13 +7218,7 @@ fn c894_l906_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11254,13 +7226,7 @@ fn c895_l907_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11268,13 +7234,7 @@ fn c896_l908_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11282,13 +7242,7 @@ fn c897_l909_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11296,13 +7250,7 @@ fn c898_l910_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11310,13 +7258,7 @@ fn c899_l911_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11324,13 +7266,7 @@ fn c900_l912_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11338,13 +7274,7 @@ fn c901_l913_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11352,13 +7282,7 @@ fn c902_l914_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11366,13 +7290,7 @@ fn c903_l915_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11380,13 +7298,7 @@ fn c904_l916_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11394,13 +7306,7 @@ fn c905_l917_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11408,13 +7314,7 @@ fn c906_l918_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11422,13 +7322,7 @@ fn c907_l919_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11436,13 +7330,7 @@ fn c908_l920_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11450,13 +7338,7 @@ fn c909_l921_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11464,13 +7346,7 @@ fn c910_l922_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11478,13 +7354,7 @@ fn c911_l923_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11492,13 +7362,7 @@ fn c912_l924_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11506,13 +7370,7 @@ fn c913_l925_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11520,13 +7378,7 @@ fn c914_l926_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11534,13 +7386,7 @@ fn c915_l927_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11548,13 +7394,7 @@ fn c916_l928_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11562,13 +7402,7 @@ fn c917_l929_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11576,13 +7410,7 @@ fn c918_l930_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11590,13 +7418,7 @@ fn c919_l931_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11636,13 +7458,7 @@ fn c924_l936_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11650,13 +7466,7 @@ fn c925_l937_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11664,13 +7474,7 @@ fn c926_l938_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11678,13 +7482,7 @@ fn c927_l939_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11692,13 +7490,7 @@ fn c928_l940_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11706,13 +7498,7 @@ fn c929_l941_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11720,13 +7506,7 @@ fn c930_l942_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11734,13 +7514,7 @@ fn c931_l943_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11844,13 +7618,7 @@ fn c944_l956_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11858,13 +7626,7 @@ fn c945_l957_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11872,13 +7634,7 @@ fn c946_l958_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11886,13 +7642,7 @@ fn c947_l959_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -11900,10 +7650,7 @@ fn c948_l960_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11935,13 +7682,7 @@ fn c952_l964_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11949,13 +7690,7 @@ fn c953_l965_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11963,13 +7698,7 @@ fn c954_l966_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11977,13 +7706,7 @@ fn c955_l967_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11991,10 +7714,7 @@ fn c956_l968_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12002,10 +7722,7 @@ fn c957_l969_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12013,10 +7730,7 @@ fn c958_l970_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12024,10 +7738,7 @@ fn c959_l971_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12067,13 +7778,7 @@ fn c964_l976_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12081,13 +7786,7 @@ fn c965_l977_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12095,13 +7794,7 @@ fn c966_l978_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12109,13 +7802,7 @@ fn c967_l979_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12123,13 +7810,7 @@ fn c968_l980_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12137,13 +7818,7 @@ fn c969_l981_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12151,13 +7826,7 @@ fn c970_l982_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12165,13 +7834,7 @@ fn c971_l983_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12275,13 +7938,7 @@ fn c984_l996_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12289,13 +7946,7 @@ fn c985_l997_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12303,13 +7954,7 @@ fn c986_l998_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12317,13 +7962,7 @@ fn c987_l999_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12331,10 +7970,7 @@ fn c988_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12366,13 +8002,7 @@ fn c992_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12380,13 +8010,7 @@ fn c993_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12394,13 +8018,7 @@ fn c994_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12408,13 +8026,7 @@ fn c995_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12422,10 +8034,7 @@ fn c996_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12433,10 +8042,7 @@ fn c997_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12444,10 +8050,7 @@ fn c998_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12455,10 +8058,7 @@ fn c999_l1011_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12498,13 +8098,7 @@ fn c1004_l1016_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12512,13 +8106,7 @@ fn c1005_l1017_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12526,13 +8114,7 @@ fn c1006_l1018_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12540,13 +8122,7 @@ fn c1007_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12554,13 +8130,7 @@ fn c1008_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12568,13 +8138,7 @@ fn c1009_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12582,13 +8146,7 @@ fn c1010_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12596,13 +8154,7 @@ fn c1011_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12674,10 +8226,7 @@ fn c1020_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12685,10 +8234,7 @@ fn c1021_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12696,10 +8242,7 @@ fn c1022_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12707,10 +8250,7 @@ fn c1023_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12718,13 +8258,7 @@ fn c1024_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12732,13 +8266,7 @@ fn c1025_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12746,13 +8274,7 @@ fn c1026_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12760,13 +8282,7 @@ fn c1027_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12774,10 +8290,7 @@ fn c1028_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12785,10 +8298,7 @@ fn c1029_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12796,10 +8306,7 @@ fn c1030_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12807,10 +8314,7 @@ fn c1031_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12818,13 +8322,7 @@ fn c1032_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12832,13 +8330,7 @@ fn c1033_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12846,13 +8338,7 @@ fn c1034_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12860,13 +8346,7 @@ fn c1035_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12874,13 +8354,7 @@ fn c1036_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12888,13 +8362,7 @@ fn c1037_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12902,13 +8370,7 @@ fn c1038_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12916,13 +8378,7 @@ fn c1039_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12930,13 +8386,7 @@ fn c1040_l1052_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12944,13 +8394,7 @@ fn c1041_l1053_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12958,13 +8402,7 @@ fn c1042_l1054_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12972,13 +8410,7 @@ fn c1043_l1055_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12986,13 +8418,7 @@ fn c1044_l1056_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13000,13 +8426,7 @@ fn c1045_l1057_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13014,13 +8434,7 @@ fn c1046_l1058_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13028,13 +8442,7 @@ fn c1047_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13042,13 +8450,7 @@ fn c1048_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13056,13 +8458,7 @@ fn c1049_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13070,13 +8466,7 @@ fn c1050_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13084,13 +8474,7 @@ fn c1051_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13098,13 +8482,7 @@ fn c1052_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13112,13 +8490,7 @@ fn c1053_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13126,13 +8498,7 @@ fn c1054_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13140,13 +8506,7 @@ fn c1055_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13154,13 +8514,7 @@ fn c1056_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13168,13 +8522,7 @@ fn c1057_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13182,13 +8530,7 @@ fn c1058_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13196,13 +8538,7 @@ fn c1059_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13210,13 +8546,7 @@ fn c1060_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13224,13 +8554,7 @@ fn c1061_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13238,13 +8562,7 @@ fn c1062_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13252,13 +8570,7 @@ fn c1063_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13266,13 +8578,7 @@ fn c1064_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13280,13 +8586,7 @@ fn c1065_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13294,13 +8594,7 @@ fn c1066_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13308,13 +8602,7 @@ fn c1067_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13322,13 +8610,7 @@ fn c1068_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13336,13 +8618,7 @@ fn c1069_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13350,13 +8626,7 @@ fn c1070_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13364,13 +8634,7 @@ fn c1071_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13378,13 +8642,7 @@ fn c1072_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13392,13 +8650,7 @@ fn c1073_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13406,13 +8658,7 @@ fn c1074_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13420,13 +8666,7 @@ fn c1075_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13434,13 +8674,7 @@ fn c1076_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13448,13 +8682,7 @@ fn c1077_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13462,13 +8690,7 @@ fn c1078_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13476,13 +8698,7 @@ fn c1079_l1091_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13490,10 +8706,7 @@ fn c1080_l1092_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13525,13 +8738,7 @@ fn c1084_l1096_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13539,13 +8746,7 @@ fn c1085_l1097_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13553,13 +8754,7 @@ fn c1086_l1098_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13567,13 +8762,7 @@ fn c1087_l1099_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13581,13 +8770,7 @@ fn c1088_l1100_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13595,13 +8778,7 @@ fn c1089_l1101_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13609,13 +8786,7 @@ fn c1090_l1102_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13623,13 +8794,7 @@ fn c1091_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13637,10 +8802,7 @@ fn c1092_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13672,10 +8834,7 @@ fn c1096_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13707,10 +8866,7 @@ fn c1100_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13718,10 +8874,7 @@ fn c1101_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13729,10 +8882,7 @@ fn c1102_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13740,10 +8890,7 @@ fn c1103_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13751,13 +8898,7 @@ fn c1104_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13765,13 +8906,7 @@ fn c1105_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13779,13 +8914,7 @@ fn c1106_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13793,13 +8922,7 @@ fn c1107_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13807,10 +8930,7 @@ fn c1108_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13818,10 +8938,7 @@ fn c1109_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13829,10 +8946,7 @@ fn c1110_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13840,10 +8954,7 @@ fn c1111_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13851,13 +8962,7 @@ fn c1112_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13865,13 +8970,7 @@ fn c1113_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13879,13 +8978,7 @@ fn c1114_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13893,13 +8986,7 @@ fn c1115_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13907,13 +8994,7 @@ fn c1116_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13921,13 +9002,7 @@ fn c1117_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13935,13 +9010,7 @@ fn c1118_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13949,13 +9018,7 @@ fn c1119_l1131_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13963,13 +9026,7 @@ fn c1120_l1132_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13977,13 +9034,7 @@ fn c1121_l1133_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13991,10 +9042,7 @@ fn c1122_l1134_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14002,10 +9050,7 @@ fn c1123_l1135_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14013,13 +9058,7 @@ fn c1124_l1136_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14027,13 +9066,7 @@ fn c1125_l1137_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14041,10 +9074,7 @@ fn c1126_l1138_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14052,10 +9082,7 @@ fn c1127_l1139_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14063,13 +9090,7 @@ fn c1128_l1140_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14077,13 +9098,7 @@ fn c1129_l1141_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14091,13 +9106,7 @@ fn c1130_l1142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14105,13 +9114,7 @@ fn c1131_l1143_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14119,13 +9122,7 @@ fn c1132_l1144_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14133,13 +9130,7 @@ fn c1133_l1145_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14147,13 +9138,7 @@ fn c1134_l1146_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14161,13 +9146,7 @@ fn c1135_l1147_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14175,13 +9154,7 @@ fn c1136_l1148_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14189,13 +9162,7 @@ fn c1137_l1149_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14203,13 +9170,7 @@ fn c1138_l1150_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14217,13 +9178,7 @@ fn c1139_l1151_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14231,13 +9186,7 @@ fn c1140_l1152_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14245,13 +9194,7 @@ fn c1141_l1153_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14259,13 +9202,7 @@ fn c1142_l1154_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14273,13 +9210,7 @@ fn c1143_l1155_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14287,13 +9218,7 @@ fn c1144_l1156_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14301,13 +9226,7 @@ fn c1145_l1157_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14315,10 +9234,7 @@ fn c1146_l1158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14326,10 +9242,7 @@ fn c1147_l1159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14337,13 +9250,7 @@ fn c1148_l1160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14351,13 +9258,7 @@ fn c1149_l1161_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14365,10 +9266,7 @@ fn c1150_l1162_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14376,10 +9274,7 @@ fn c1151_l1163_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14387,13 +9282,7 @@ fn c1152_l1164_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14401,13 +9290,7 @@ fn c1153_l1165_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14415,10 +9298,7 @@ fn c1154_l1166_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14426,10 +9306,7 @@ fn c1155_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14437,13 +9314,7 @@ fn c1156_l1168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14451,13 +9322,7 @@ fn c1157_l1169_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14465,10 +9330,7 @@ fn c1158_l1170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14476,10 +9338,7 @@ fn c1159_l1171_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14487,13 +9346,7 @@ fn c1160_l1172_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14501,13 +9354,7 @@ fn c1161_l1173_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14515,13 +9362,7 @@ fn c1162_l1174_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14529,13 +9370,7 @@ fn c1163_l1175_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14543,13 +9378,7 @@ fn c1164_l1176_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14557,13 +9386,7 @@ fn c1165_l1177_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14571,13 +9394,7 @@ fn c1166_l1178_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14585,13 +9402,7 @@ fn c1167_l1179_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14599,13 +9410,7 @@ fn c1168_l1180_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14613,13 +9418,7 @@ fn c1169_l1181_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14627,13 +9426,7 @@ fn c1170_l1182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14641,13 +9434,7 @@ fn c1171_l1183_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14655,13 +9442,7 @@ fn c1172_l1184_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14669,13 +9450,7 @@ fn c1173_l1185_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14683,13 +9458,7 @@ fn c1174_l1186_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14697,13 +9466,7 @@ fn c1175_l1187_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14711,13 +9474,7 @@ fn c1176_l1188_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14725,13 +9482,7 @@ fn c1177_l1189_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14739,13 +9490,7 @@ fn c1178_l1190_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14753,13 +9498,7 @@ fn c1179_l1191_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14767,13 +9506,7 @@ fn c1180_l1192_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14781,13 +9514,7 @@ fn c1181_l1193_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14795,13 +9522,7 @@ fn c1182_l1194_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14809,13 +9530,7 @@ fn c1183_l1195_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14823,13 +9538,7 @@ fn c1184_l1196_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14837,13 +9546,7 @@ fn c1185_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14851,13 +9554,7 @@ fn c1186_l1198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14865,13 +9562,7 @@ fn c1187_l1199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14879,13 +9570,7 @@ fn c1188_l1200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14893,13 +9578,7 @@ fn c1189_l1201_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14907,13 +9586,7 @@ fn c1190_l1202_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14921,13 +9594,7 @@ fn c1191_l1203_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14935,13 +9602,7 @@ fn c1192_l1204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14949,13 +9610,7 @@ fn c1193_l1205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14963,13 +9618,7 @@ fn c1194_l1206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14977,13 +9626,7 @@ fn c1195_l1207_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14991,13 +9634,7 @@ fn c1196_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15005,13 +9642,7 @@ fn c1197_l1209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15019,13 +9650,7 @@ fn c1198_l1210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15033,13 +9658,7 @@ fn c1199_l1211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15079,13 +9698,7 @@ fn c1204_l1216_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15093,13 +9706,7 @@ fn c1205_l1217_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15107,13 +9714,7 @@ fn c1206_l1218_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15121,13 +9722,7 @@ fn c1207_l1219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15135,13 +9730,7 @@ fn c1208_l1220_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15149,13 +9738,7 @@ fn c1209_l1221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15163,13 +9746,7 @@ fn c1210_l1222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15177,13 +9754,7 @@ fn c1211_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15287,13 +9858,7 @@ fn c1224_l1236_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15301,13 +9866,7 @@ fn c1225_l1237_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15315,13 +9874,7 @@ fn c1226_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15329,13 +9882,7 @@ fn c1227_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15343,10 +9890,7 @@ fn c1228_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15378,13 +9922,7 @@ fn c1232_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15392,13 +9930,7 @@ fn c1233_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15406,13 +9938,7 @@ fn c1234_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15420,13 +9946,7 @@ fn c1235_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15434,10 +9954,7 @@ fn c1236_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15445,10 +9962,7 @@ fn c1237_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15456,10 +9970,7 @@ fn c1238_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15467,10 +9978,7 @@ fn c1239_l1251_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15478,13 +9986,7 @@ fn c1240_l1252_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15492,13 +9994,7 @@ fn c1241_l1253_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15506,13 +10002,7 @@ fn c1242_l1254_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15520,13 +10010,7 @@ fn c1243_l1255_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15534,13 +10018,7 @@ fn c1244_l1256_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15548,13 +10026,7 @@ fn c1245_l1257_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15562,13 +10034,7 @@ fn c1246_l1258_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15576,13 +10042,7 @@ fn c1247_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15590,13 +10050,7 @@ fn c1248_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15604,13 +10058,7 @@ fn c1249_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15618,13 +10066,7 @@ fn c1250_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15632,13 +10074,7 @@ fn c1251_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15646,13 +10082,7 @@ fn c1252_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15660,13 +10090,7 @@ fn c1253_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15674,13 +10098,7 @@ fn c1254_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15688,13 +10106,7 @@ fn c1255_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15702,13 +10114,7 @@ fn c1256_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15716,13 +10122,7 @@ fn c1257_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15730,13 +10130,7 @@ fn c1258_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15744,13 +10138,7 @@ fn c1259_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15758,13 +10146,7 @@ fn c1260_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15772,13 +10154,7 @@ fn c1261_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15786,13 +10162,7 @@ fn c1262_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15800,13 +10170,7 @@ fn c1263_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15814,13 +10178,7 @@ fn c1264_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15828,13 +10186,7 @@ fn c1265_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15842,13 +10194,7 @@ fn c1266_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15856,13 +10202,7 @@ fn c1267_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15870,13 +10210,7 @@ fn c1268_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15884,13 +10218,7 @@ fn c1269_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15898,13 +10226,7 @@ fn c1270_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15912,13 +10234,7 @@ fn c1271_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -15926,13 +10242,7 @@ fn c1272_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15940,13 +10250,7 @@ fn c1273_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15954,13 +10258,7 @@ fn c1274_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15968,13 +10266,7 @@ fn c1275_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15982,13 +10274,7 @@ fn c1276_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15996,13 +10282,7 @@ fn c1277_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16010,13 +10290,7 @@ fn c1278_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16024,13 +10298,7 @@ fn c1279_l1291_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16038,13 +10306,7 @@ fn c1280_l1292_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16052,13 +10314,7 @@ fn c1281_l1293_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16066,13 +10322,7 @@ fn c1282_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16080,13 +10330,7 @@ fn c1283_l1295_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16094,13 +10338,7 @@ fn c1284_l1296_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16108,13 +10346,7 @@ fn c1285_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16122,13 +10354,7 @@ fn c1286_l1298_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16136,13 +10362,7 @@ fn c1287_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16150,13 +10370,7 @@ fn c1288_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16164,13 +10378,7 @@ fn c1289_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16178,13 +10386,7 @@ fn c1290_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16192,13 +10394,7 @@ fn c1291_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16206,13 +10402,7 @@ fn c1292_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16220,13 +10410,7 @@ fn c1293_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16234,13 +10418,7 @@ fn c1294_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16248,13 +10426,7 @@ fn c1295_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16262,13 +10434,7 @@ fn c1296_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16276,13 +10442,7 @@ fn c1297_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16290,13 +10450,7 @@ fn c1298_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16304,13 +10458,7 @@ fn c1299_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16318,13 +10466,7 @@ fn c1300_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16332,13 +10474,7 @@ fn c1301_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16346,13 +10482,7 @@ fn c1302_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16360,13 +10490,7 @@ fn c1303_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16374,13 +10498,7 @@ fn c1304_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16388,13 +10506,7 @@ fn c1305_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16402,13 +10514,7 @@ fn c1306_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16416,13 +10522,7 @@ fn c1307_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16430,13 +10530,7 @@ fn c1308_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16444,13 +10538,7 @@ fn c1309_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16458,13 +10546,7 @@ fn c1310_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16472,13 +10554,7 @@ fn c1311_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16486,13 +10562,7 @@ fn c1312_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16500,13 +10570,7 @@ fn c1313_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16514,13 +10578,7 @@ fn c1314_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16528,13 +10586,7 @@ fn c1315_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16542,13 +10594,7 @@ fn c1316_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16556,13 +10602,7 @@ fn c1317_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16570,13 +10610,7 @@ fn c1318_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16584,13 +10618,7 @@ fn c1319_l1331_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16630,13 +10658,7 @@ fn c1324_l1336_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16644,13 +10666,7 @@ fn c1325_l1337_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16658,13 +10674,7 @@ fn c1326_l1338_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16672,13 +10682,7 @@ fn c1327_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16686,13 +10690,7 @@ fn c1328_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16700,13 +10698,7 @@ fn c1329_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16714,13 +10706,7 @@ fn c1330_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16728,13 +10714,7 @@ fn c1331_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16838,13 +10818,7 @@ fn c1344_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16852,13 +10826,7 @@ fn c1345_l1357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16866,13 +10834,7 @@ fn c1346_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16880,13 +10842,7 @@ fn c1347_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16894,10 +10850,7 @@ fn c1348_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16929,13 +10882,7 @@ fn c1352_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16943,13 +10890,7 @@ fn c1353_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16957,13 +10898,7 @@ fn c1354_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16971,13 +10906,7 @@ fn c1355_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16985,10 +10914,7 @@ fn c1356_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16996,10 +10922,7 @@ fn c1357_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17007,10 +10930,7 @@ fn c1358_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17018,10 +10938,7 @@ fn c1359_l1371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17061,13 +10978,7 @@ fn c1364_l1376_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17075,13 +10986,7 @@ fn c1365_l1377_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17089,13 +10994,7 @@ fn c1366_l1378_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17103,13 +11002,7 @@ fn c1367_l1379_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17117,13 +11010,7 @@ fn c1368_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17131,13 +11018,7 @@ fn c1369_l1381_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17145,13 +11026,7 @@ fn c1370_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17159,13 +11034,7 @@ fn c1371_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17269,13 +11138,7 @@ fn c1384_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17283,13 +11146,7 @@ fn c1385_l1397_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17297,13 +11154,7 @@ fn c1386_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17311,13 +11162,7 @@ fn c1387_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17325,10 +11170,7 @@ fn c1388_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17360,13 +11202,7 @@ fn c1392_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17374,13 +11210,7 @@ fn c1393_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17388,13 +11218,7 @@ fn c1394_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17402,13 +11226,7 @@ fn c1395_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17416,10 +11234,7 @@ fn c1396_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17427,10 +11242,7 @@ fn c1397_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17438,10 +11250,7 @@ fn c1398_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17449,10 +11258,7 @@ fn c1399_l1411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17492,13 +11298,7 @@ fn c1404_l1416_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17506,13 +11306,7 @@ fn c1405_l1417_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17520,13 +11314,7 @@ fn c1406_l1418_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17534,13 +11322,7 @@ fn c1407_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17548,13 +11330,7 @@ fn c1408_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17562,13 +11338,7 @@ fn c1409_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17576,13 +11346,7 @@ fn c1410_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17590,13 +11354,7 @@ fn c1411_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17668,10 +11426,7 @@ fn c1420_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17679,10 +11434,7 @@ fn c1421_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17690,10 +11442,7 @@ fn c1422_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17701,10 +11450,7 @@ fn c1423_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17712,13 +11458,7 @@ fn c1424_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17726,13 +11466,7 @@ fn c1425_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17740,13 +11474,7 @@ fn c1426_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17754,13 +11482,7 @@ fn c1427_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17768,10 +11490,7 @@ fn c1428_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17779,10 +11498,7 @@ fn c1429_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17790,10 +11506,7 @@ fn c1430_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17801,10 +11514,7 @@ fn c1431_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17812,13 +11522,7 @@ fn c1432_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17826,13 +11530,7 @@ fn c1433_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17840,13 +11538,7 @@ fn c1434_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17854,13 +11546,7 @@ fn c1435_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17868,13 +11554,7 @@ fn c1436_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17882,13 +11562,7 @@ fn c1437_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17896,13 +11570,7 @@ fn c1438_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17910,13 +11578,7 @@ fn c1439_l1451_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17924,13 +11586,7 @@ fn c1440_l1452_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17938,13 +11594,7 @@ fn c1441_l1453_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17952,13 +11602,7 @@ fn c1442_l1454_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17966,13 +11610,7 @@ fn c1443_l1455_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17980,13 +11618,7 @@ fn c1444_l1456_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17994,13 +11626,7 @@ fn c1445_l1457_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18008,13 +11634,7 @@ fn c1446_l1458_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18022,13 +11642,7 @@ fn c1447_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18036,13 +11650,7 @@ fn c1448_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18050,13 +11658,7 @@ fn c1449_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18064,13 +11666,7 @@ fn c1450_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18078,13 +11674,7 @@ fn c1451_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18092,13 +11682,7 @@ fn c1452_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18106,13 +11690,7 @@ fn c1453_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18120,13 +11698,7 @@ fn c1454_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18134,13 +11706,7 @@ fn c1455_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18148,13 +11714,7 @@ fn c1456_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18162,13 +11722,7 @@ fn c1457_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18176,13 +11730,7 @@ fn c1458_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18190,13 +11738,7 @@ fn c1459_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18204,13 +11746,7 @@ fn c1460_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18218,13 +11754,7 @@ fn c1461_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18232,13 +11762,7 @@ fn c1462_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18246,13 +11770,7 @@ fn c1463_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18260,13 +11778,7 @@ fn c1464_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18274,13 +11786,7 @@ fn c1465_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18288,13 +11794,7 @@ fn c1466_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18302,13 +11802,7 @@ fn c1467_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18316,13 +11810,7 @@ fn c1468_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18330,13 +11818,7 @@ fn c1469_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18344,13 +11826,7 @@ fn c1470_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18358,13 +11834,7 @@ fn c1471_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18372,13 +11842,7 @@ fn c1472_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18386,13 +11850,7 @@ fn c1473_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18400,13 +11858,7 @@ fn c1474_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18414,13 +11866,7 @@ fn c1475_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18428,13 +11874,7 @@ fn c1476_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18442,13 +11882,7 @@ fn c1477_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18456,13 +11890,7 @@ fn c1478_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18470,13 +11898,7 @@ fn c1479_l1491_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18484,10 +11906,7 @@ fn c1480_l1492_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18519,13 +11938,7 @@ fn c1484_l1496_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18533,13 +11946,7 @@ fn c1485_l1497_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18547,13 +11954,7 @@ fn c1486_l1498_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18561,13 +11962,7 @@ fn c1487_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18575,13 +11970,7 @@ fn c1488_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18589,13 +11978,7 @@ fn c1489_l1501_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18603,13 +11986,7 @@ fn c1490_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18617,13 +11994,7 @@ fn c1491_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18631,10 +12002,7 @@ fn c1492_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18666,10 +12034,7 @@ fn c1496_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18701,10 +12066,7 @@ fn c1500_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18712,10 +12074,7 @@ fn c1501_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18723,10 +12082,7 @@ fn c1502_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18734,10 +12090,7 @@ fn c1503_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18745,13 +12098,7 @@ fn c1504_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18759,13 +12106,7 @@ fn c1505_l1517_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18773,13 +12114,7 @@ fn c1506_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18787,13 +12122,7 @@ fn c1507_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18801,10 +12130,7 @@ fn c1508_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18812,10 +12138,7 @@ fn c1509_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18823,10 +12146,7 @@ fn c1510_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18834,10 +12154,7 @@ fn c1511_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18845,13 +12162,7 @@ fn c1512_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18859,13 +12170,7 @@ fn c1513_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18873,13 +12178,7 @@ fn c1514_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18887,13 +12186,7 @@ fn c1515_l1527_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18901,13 +12194,7 @@ fn c1516_l1528_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18915,13 +12202,7 @@ fn c1517_l1529_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18929,13 +12210,7 @@ fn c1518_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18943,13 +12218,7 @@ fn c1519_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18957,13 +12226,7 @@ fn c1520_l1532_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18971,13 +12234,7 @@ fn c1521_l1533_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18985,10 +12242,7 @@ fn c1522_l1534_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18996,10 +12250,7 @@ fn c1523_l1535_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19007,13 +12258,7 @@ fn c1524_l1536_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19021,13 +12266,7 @@ fn c1525_l1537_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19035,10 +12274,7 @@ fn c1526_l1538_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19046,10 +12282,7 @@ fn c1527_l1539_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19057,13 +12290,7 @@ fn c1528_l1540_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19071,13 +12298,7 @@ fn c1529_l1541_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19085,13 +12306,7 @@ fn c1530_l1542_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19099,13 +12314,7 @@ fn c1531_l1543_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19113,13 +12322,7 @@ fn c1532_l1544_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19127,13 +12330,7 @@ fn c1533_l1545_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19141,13 +12338,7 @@ fn c1534_l1546_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19155,13 +12346,7 @@ fn c1535_l1547_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19169,13 +12354,7 @@ fn c1536_l1548_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19183,13 +12362,7 @@ fn c1537_l1549_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19197,13 +12370,7 @@ fn c1538_l1550_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19211,13 +12378,7 @@ fn c1539_l1551_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19225,13 +12386,7 @@ fn c1540_l1552_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19239,13 +12394,7 @@ fn c1541_l1553_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19253,13 +12402,7 @@ fn c1542_l1554_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19267,13 +12410,7 @@ fn c1543_l1555_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19281,13 +12418,7 @@ fn c1544_l1556_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19295,13 +12426,7 @@ fn c1545_l1557_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19309,10 +12434,7 @@ fn c1546_l1558_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19320,10 +12442,7 @@ fn c1547_l1559_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19331,13 +12450,7 @@ fn c1548_l1560_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19345,13 +12458,7 @@ fn c1549_l1561_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19359,10 +12466,7 @@ fn c1550_l1562_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19370,10 +12474,7 @@ fn c1551_l1563_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19381,13 +12482,7 @@ fn c1552_l1564_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19395,13 +12490,7 @@ fn c1553_l1565_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19409,10 +12498,7 @@ fn c1554_l1566_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19420,10 +12506,7 @@ fn c1555_l1567_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19431,13 +12514,7 @@ fn c1556_l1568_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19445,13 +12522,7 @@ fn c1557_l1569_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19459,10 +12530,7 @@ fn c1558_l1570_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19470,10 +12538,7 @@ fn c1559_l1571_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19481,13 +12546,7 @@ fn c1560_l1572_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19495,13 +12554,7 @@ fn c1561_l1573_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19509,13 +12562,7 @@ fn c1562_l1574_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19523,13 +12570,7 @@ fn c1563_l1575_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19537,13 +12578,7 @@ fn c1564_l1576_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19551,13 +12586,7 @@ fn c1565_l1577_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19565,13 +12594,7 @@ fn c1566_l1578_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19579,13 +12602,7 @@ fn c1567_l1579_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19593,13 +12610,7 @@ fn c1568_l1580_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19607,13 +12618,7 @@ fn c1569_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19621,13 +12626,7 @@ fn c1570_l1582_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19635,13 +12634,7 @@ fn c1571_l1583_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19649,13 +12642,7 @@ fn c1572_l1584_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19663,13 +12650,7 @@ fn c1573_l1585_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19677,13 +12658,7 @@ fn c1574_l1586_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19691,13 +12666,7 @@ fn c1575_l1587_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19705,13 +12674,7 @@ fn c1576_l1588_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19719,13 +12682,7 @@ fn c1577_l1589_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19733,13 +12690,7 @@ fn c1578_l1590_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19747,13 +12698,7 @@ fn c1579_l1591_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19761,13 +12706,7 @@ fn c1580_l1592_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19775,13 +12714,7 @@ fn c1581_l1593_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19789,13 +12722,7 @@ fn c1582_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19803,13 +12730,7 @@ fn c1583_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19817,13 +12738,7 @@ fn c1584_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19831,13 +12746,7 @@ fn c1585_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19845,13 +12754,7 @@ fn c1586_l1598_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19859,13 +12762,7 @@ fn c1587_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19873,13 +12770,7 @@ fn c1588_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19887,13 +12778,7 @@ fn c1589_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19901,13 +12786,7 @@ fn c1590_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19915,13 +12794,7 @@ fn c1591_l1603_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19929,13 +12802,7 @@ fn c1592_l1604_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19943,13 +12810,7 @@ fn c1593_l1605_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19957,13 +12818,7 @@ fn c1594_l1606_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19971,13 +12826,7 @@ fn c1595_l1607_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19985,13 +12834,7 @@ fn c1596_l1608_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19999,13 +12842,7 @@ fn c1597_l1609_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20013,13 +12850,7 @@ fn c1598_l1610_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20027,13 +12858,7 @@ fn c1599_l1611_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20073,13 +12898,7 @@ fn c1604_l1616_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20087,13 +12906,7 @@ fn c1605_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20101,13 +12914,7 @@ fn c1606_l1618_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20115,13 +12922,7 @@ fn c1607_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20129,13 +12930,7 @@ fn c1608_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20143,13 +12938,7 @@ fn c1609_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20157,13 +12946,7 @@ fn c1610_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20171,13 +12954,7 @@ fn c1611_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20281,13 +13058,7 @@ fn c1624_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20295,13 +13066,7 @@ fn c1625_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20309,13 +13074,7 @@ fn c1626_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20323,13 +13082,7 @@ fn c1627_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20337,10 +13090,7 @@ fn c1628_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20372,13 +13122,7 @@ fn c1632_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20386,13 +13130,7 @@ fn c1633_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20400,13 +13138,7 @@ fn c1634_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20414,13 +13146,7 @@ fn c1635_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20428,10 +13154,7 @@ fn c1636_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20439,10 +13162,7 @@ fn c1637_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20450,10 +13170,7 @@ fn c1638_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20461,10 +13178,7 @@ fn c1639_l1651_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20472,13 +13186,7 @@ fn c1640_l1652_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20486,13 +13194,7 @@ fn c1641_l1653_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20500,13 +13202,7 @@ fn c1642_l1654_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20514,13 +13210,7 @@ fn c1643_l1655_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20528,13 +13218,7 @@ fn c1644_l1656_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20542,13 +13226,7 @@ fn c1645_l1657_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20556,13 +13234,7 @@ fn c1646_l1658_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20570,13 +13242,7 @@ fn c1647_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20584,13 +13250,7 @@ fn c1648_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20598,13 +13258,7 @@ fn c1649_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20612,13 +13266,7 @@ fn c1650_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20626,13 +13274,7 @@ fn c1651_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20640,13 +13282,7 @@ fn c1652_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20654,13 +13290,7 @@ fn c1653_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20668,13 +13298,7 @@ fn c1654_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20682,13 +13306,7 @@ fn c1655_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20696,13 +13314,7 @@ fn c1656_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20710,13 +13322,7 @@ fn c1657_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20724,13 +13330,7 @@ fn c1658_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20738,13 +13338,7 @@ fn c1659_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20752,13 +13346,7 @@ fn c1660_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20766,13 +13354,7 @@ fn c1661_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20780,13 +13362,7 @@ fn c1662_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20794,13 +13370,7 @@ fn c1663_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20808,13 +13378,7 @@ fn c1664_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20822,13 +13386,7 @@ fn c1665_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20836,13 +13394,7 @@ fn c1666_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20850,13 +13402,7 @@ fn c1667_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20864,13 +13410,7 @@ fn c1668_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20878,13 +13418,7 @@ fn c1669_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20892,13 +13426,7 @@ fn c1670_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20906,13 +13434,7 @@ fn c1671_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20920,13 +13442,7 @@ fn c1672_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20934,13 +13450,7 @@ fn c1673_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20948,13 +13458,7 @@ fn c1674_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20962,13 +13466,7 @@ fn c1675_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20976,13 +13474,7 @@ fn c1676_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20990,13 +13482,7 @@ fn c1677_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21004,13 +13490,7 @@ fn c1678_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21018,13 +13498,7 @@ fn c1679_l1691_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21032,13 +13506,7 @@ fn c1680_l1692_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21046,13 +13514,7 @@ fn c1681_l1693_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21060,13 +13522,7 @@ fn c1682_l1694_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21074,13 +13530,7 @@ fn c1683_l1695_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21088,13 +13538,7 @@ fn c1684_l1696_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21102,13 +13546,7 @@ fn c1685_l1697_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21116,13 +13554,7 @@ fn c1686_l1698_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21130,13 +13562,7 @@ fn c1687_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21144,13 +13570,7 @@ fn c1688_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21158,13 +13578,7 @@ fn c1689_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21172,13 +13586,7 @@ fn c1690_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21186,13 +13594,7 @@ fn c1691_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21200,13 +13602,7 @@ fn c1692_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21214,13 +13610,7 @@ fn c1693_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21228,13 +13618,7 @@ fn c1694_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21242,13 +13626,7 @@ fn c1695_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21256,13 +13634,7 @@ fn c1696_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21270,13 +13642,7 @@ fn c1697_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21284,13 +13650,7 @@ fn c1698_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21298,13 +13658,7 @@ fn c1699_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21312,13 +13666,7 @@ fn c1700_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21326,13 +13674,7 @@ fn c1701_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21340,13 +13682,7 @@ fn c1702_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21354,13 +13690,7 @@ fn c1703_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21368,13 +13698,7 @@ fn c1704_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21382,13 +13706,7 @@ fn c1705_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21396,13 +13714,7 @@ fn c1706_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21410,13 +13722,7 @@ fn c1707_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21424,13 +13730,7 @@ fn c1708_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21438,13 +13738,7 @@ fn c1709_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21452,13 +13746,7 @@ fn c1710_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21466,13 +13754,7 @@ fn c1711_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21480,13 +13762,7 @@ fn c1712_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21494,13 +13770,7 @@ fn c1713_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21508,13 +13778,7 @@ fn c1714_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21522,13 +13786,7 @@ fn c1715_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21536,13 +13794,7 @@ fn c1716_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21550,13 +13802,7 @@ fn c1717_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21564,13 +13810,7 @@ fn c1718_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21578,13 +13818,7 @@ fn c1719_l1731_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21624,13 +13858,7 @@ fn c1724_l1736_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21638,13 +13866,7 @@ fn c1725_l1737_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21652,13 +13874,7 @@ fn c1726_l1738_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21666,13 +13882,7 @@ fn c1727_l1739_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21680,13 +13890,7 @@ fn c1728_l1740_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21694,13 +13898,7 @@ fn c1729_l1741_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21708,13 +13906,7 @@ fn c1730_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21722,13 +13914,7 @@ fn c1731_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21832,13 +14018,7 @@ fn c1744_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21846,13 +14026,7 @@ fn c1745_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21860,13 +14034,7 @@ fn c1746_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21874,13 +14042,7 @@ fn c1747_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21888,10 +14050,7 @@ fn c1748_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21923,13 +14082,7 @@ fn c1752_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21937,13 +14090,7 @@ fn c1753_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21951,13 +14098,7 @@ fn c1754_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21965,13 +14106,7 @@ fn c1755_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21979,10 +14114,7 @@ fn c1756_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21990,10 +14122,7 @@ fn c1757_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22001,10 +14130,7 @@ fn c1758_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22012,10 +14138,7 @@ fn c1759_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22055,13 +14178,7 @@ fn c1764_l1776_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22069,13 +14186,7 @@ fn c1765_l1777_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22083,13 +14194,7 @@ fn c1766_l1778_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22097,13 +14202,7 @@ fn c1767_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22111,13 +14210,7 @@ fn c1768_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22125,13 +14218,7 @@ fn c1769_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22139,13 +14226,7 @@ fn c1770_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22153,13 +14234,7 @@ fn c1771_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22263,13 +14338,7 @@ fn c1784_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22277,13 +14346,7 @@ fn c1785_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22291,13 +14354,7 @@ fn c1786_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22305,13 +14362,7 @@ fn c1787_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22319,10 +14370,7 @@ fn c1788_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22354,13 +14402,7 @@ fn c1792_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22368,13 +14410,7 @@ fn c1793_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22382,13 +14418,7 @@ fn c1794_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22396,13 +14426,7 @@ fn c1795_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22410,10 +14434,7 @@ fn c1796_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22421,10 +14442,7 @@ fn c1797_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22432,10 +14450,7 @@ fn c1798_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22443,10 +14458,7 @@ fn c1799_l1811_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22486,13 +14498,7 @@ fn c1804_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22500,13 +14506,7 @@ fn c1805_l1817_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22514,13 +14514,7 @@ fn c1806_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22528,13 +14522,7 @@ fn c1807_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22542,13 +14530,7 @@ fn c1808_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22556,13 +14538,7 @@ fn c1809_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22570,13 +14546,7 @@ fn c1810_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22584,13 +14554,7 @@ fn c1811_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22662,10 +14626,7 @@ fn c1820_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22673,10 +14634,7 @@ fn c1821_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22684,10 +14642,7 @@ fn c1822_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22695,10 +14650,7 @@ fn c1823_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22706,13 +14658,7 @@ fn c1824_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22720,13 +14666,7 @@ fn c1825_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22734,13 +14674,7 @@ fn c1826_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22748,13 +14682,7 @@ fn c1827_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22762,10 +14690,7 @@ fn c1828_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22773,10 +14698,7 @@ fn c1829_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22784,10 +14706,7 @@ fn c1830_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22795,10 +14714,7 @@ fn c1831_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22806,13 +14722,7 @@ fn c1832_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22820,13 +14730,7 @@ fn c1833_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22834,13 +14738,7 @@ fn c1834_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22848,13 +14746,7 @@ fn c1835_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22862,13 +14754,7 @@ fn c1836_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22876,13 +14762,7 @@ fn c1837_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22890,13 +14770,7 @@ fn c1838_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22904,13 +14778,7 @@ fn c1839_l1851_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22918,13 +14786,7 @@ fn c1840_l1852_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22932,13 +14794,7 @@ fn c1841_l1853_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22946,13 +14802,7 @@ fn c1842_l1854_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22960,13 +14810,7 @@ fn c1843_l1855_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22974,13 +14818,7 @@ fn c1844_l1856_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22988,13 +14826,7 @@ fn c1845_l1857_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23002,13 +14834,7 @@ fn c1846_l1858_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23016,13 +14842,7 @@ fn c1847_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23030,13 +14850,7 @@ fn c1848_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23044,13 +14858,7 @@ fn c1849_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23058,13 +14866,7 @@ fn c1850_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23072,13 +14874,7 @@ fn c1851_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23086,13 +14882,7 @@ fn c1852_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23100,13 +14890,7 @@ fn c1853_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23114,13 +14898,7 @@ fn c1854_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23128,13 +14906,7 @@ fn c1855_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23142,13 +14914,7 @@ fn c1856_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23156,13 +14922,7 @@ fn c1857_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23170,13 +14930,7 @@ fn c1858_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23184,13 +14938,7 @@ fn c1859_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23198,13 +14946,7 @@ fn c1860_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23212,13 +14954,7 @@ fn c1861_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23226,13 +14962,7 @@ fn c1862_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23240,13 +14970,7 @@ fn c1863_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23254,13 +14978,7 @@ fn c1864_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23268,13 +14986,7 @@ fn c1865_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23282,13 +14994,7 @@ fn c1866_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23296,13 +15002,7 @@ fn c1867_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23310,13 +15010,7 @@ fn c1868_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23324,13 +15018,7 @@ fn c1869_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23338,13 +15026,7 @@ fn c1870_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23352,13 +15034,7 @@ fn c1871_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23366,13 +15042,7 @@ fn c1872_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23380,13 +15050,7 @@ fn c1873_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23394,13 +15058,7 @@ fn c1874_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23408,13 +15066,7 @@ fn c1875_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23422,13 +15074,7 @@ fn c1876_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23436,13 +15082,7 @@ fn c1877_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23450,13 +15090,7 @@ fn c1878_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23464,13 +15098,7 @@ fn c1879_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23478,10 +15106,7 @@ fn c1880_l1892_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23513,13 +15138,7 @@ fn c1884_l1896_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23527,13 +15146,7 @@ fn c1885_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23541,13 +15154,7 @@ fn c1886_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23555,13 +15162,7 @@ fn c1887_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23569,13 +15170,7 @@ fn c1888_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23583,13 +15178,7 @@ fn c1889_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23597,13 +15186,7 @@ fn c1890_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23611,13 +15194,7 @@ fn c1891_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23625,10 +15202,7 @@ fn c1892_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23660,10 +15234,7 @@ fn c1896_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23695,10 +15266,7 @@ fn c1900_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23706,10 +15274,7 @@ fn c1901_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23717,10 +15282,7 @@ fn c1902_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23728,10 +15290,7 @@ fn c1903_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23739,13 +15298,7 @@ fn c1904_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23753,13 +15306,7 @@ fn c1905_l1917_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23767,13 +15314,7 @@ fn c1906_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23781,13 +15322,7 @@ fn c1907_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23795,10 +15330,7 @@ fn c1908_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23806,10 +15338,7 @@ fn c1909_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23817,10 +15346,7 @@ fn c1910_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -23828,10 +15354,7 @@ fn c1911_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23839,13 +15362,7 @@ fn c1912_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23853,13 +15370,7 @@ fn c1913_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23867,13 +15378,7 @@ fn c1914_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23881,13 +15386,7 @@ fn c1915_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23895,13 +15394,7 @@ fn c1916_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23909,13 +15402,7 @@ fn c1917_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23923,13 +15410,7 @@ fn c1918_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23937,13 +15418,7 @@ fn c1919_l1931_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23951,13 +15426,7 @@ fn c1920_l1932_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23965,13 +15434,7 @@ fn c1921_l1933_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23979,10 +15442,7 @@ fn c1922_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23990,10 +15450,7 @@ fn c1923_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24001,13 +15458,7 @@ fn c1924_l1936_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24015,13 +15466,7 @@ fn c1925_l1937_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24029,10 +15474,7 @@ fn c1926_l1938_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24040,10 +15482,7 @@ fn c1927_l1939_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24051,13 +15490,7 @@ fn c1928_l1940_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24065,13 +15498,7 @@ fn c1929_l1941_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24079,13 +15506,7 @@ fn c1930_l1942_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24093,13 +15514,7 @@ fn c1931_l1943_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24107,13 +15522,7 @@ fn c1932_l1944_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24121,13 +15530,7 @@ fn c1933_l1945_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24135,13 +15538,7 @@ fn c1934_l1946_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24149,13 +15546,7 @@ fn c1935_l1947_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24163,13 +15554,7 @@ fn c1936_l1948_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24177,13 +15562,7 @@ fn c1937_l1949_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24191,13 +15570,7 @@ fn c1938_l1950_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24205,13 +15578,7 @@ fn c1939_l1951_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24219,13 +15586,7 @@ fn c1940_l1952_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24233,13 +15594,7 @@ fn c1941_l1953_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24247,13 +15602,7 @@ fn c1942_l1954_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24261,13 +15610,7 @@ fn c1943_l1955_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24275,13 +15618,7 @@ fn c1944_l1956_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24289,13 +15626,7 @@ fn c1945_l1957_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24303,10 +15634,7 @@ fn c1946_l1958_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24314,10 +15642,7 @@ fn c1947_l1959_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24325,13 +15650,7 @@ fn c1948_l1960_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24339,13 +15658,7 @@ fn c1949_l1961_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24353,10 +15666,7 @@ fn c1950_l1962_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24364,10 +15674,7 @@ fn c1951_l1963_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24375,13 +15682,7 @@ fn c1952_l1964_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24389,13 +15690,7 @@ fn c1953_l1965_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24403,10 +15698,7 @@ fn c1954_l1966_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24414,10 +15706,7 @@ fn c1955_l1967_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24425,13 +15714,7 @@ fn c1956_l1968_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24439,13 +15722,7 @@ fn c1957_l1969_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24453,10 +15730,7 @@ fn c1958_l1970_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24464,10 +15738,7 @@ fn c1959_l1971_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24475,13 +15746,7 @@ fn c1960_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24489,13 +15754,7 @@ fn c1961_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24503,13 +15762,7 @@ fn c1962_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24517,13 +15770,7 @@ fn c1963_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24531,13 +15778,7 @@ fn c1964_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24545,13 +15786,7 @@ fn c1965_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24559,13 +15794,7 @@ fn c1966_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24573,13 +15802,7 @@ fn c1967_l1979_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24587,13 +15810,7 @@ fn c1968_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24601,13 +15818,7 @@ fn c1969_l1981_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24615,13 +15826,7 @@ fn c1970_l1982_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24629,13 +15834,7 @@ fn c1971_l1983_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24643,13 +15842,7 @@ fn c1972_l1984_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24657,13 +15850,7 @@ fn c1973_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24671,13 +15858,7 @@ fn c1974_l1986_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24685,13 +15866,7 @@ fn c1975_l1987_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24699,13 +15874,7 @@ fn c1976_l1988_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24713,13 +15882,7 @@ fn c1977_l1989_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24727,13 +15890,7 @@ fn c1978_l1990_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24741,13 +15898,7 @@ fn c1979_l1991_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24755,13 +15906,7 @@ fn c1980_l1992_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24769,13 +15914,7 @@ fn c1981_l1993_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24783,13 +15922,7 @@ fn c1982_l1994_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24797,13 +15930,7 @@ fn c1983_l1995_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24811,13 +15938,7 @@ fn c1984_l1996_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24825,13 +15946,7 @@ fn c1985_l1997_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24839,13 +15954,7 @@ fn c1986_l1998_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24853,13 +15962,7 @@ fn c1987_l1999_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24867,13 +15970,7 @@ fn c1988_l2000_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24881,13 +15978,7 @@ fn c1989_l2001_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24895,13 +15986,7 @@ fn c1990_l2002_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24909,13 +15994,7 @@ fn c1991_l2003_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24923,13 +16002,7 @@ fn c1992_l2004_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24937,13 +16010,7 @@ fn c1993_l2005_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24951,13 +16018,7 @@ fn c1994_l2006_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24965,13 +16026,7 @@ fn c1995_l2007_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24979,13 +16034,7 @@ fn c1996_l2008_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -24993,13 +16042,7 @@ fn c1997_l2009_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25007,13 +16050,7 @@ fn c1998_l2010_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25021,13 +16058,7 @@ fn c1999_l2011_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25067,13 +16098,7 @@ fn c2004_l2016_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25081,13 +16106,7 @@ fn c2005_l2017_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25095,13 +16114,7 @@ fn c2006_l2018_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25109,13 +16122,7 @@ fn c2007_l2019_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25123,13 +16130,7 @@ fn c2008_l2020_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25137,13 +16138,7 @@ fn c2009_l2021_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25151,13 +16146,7 @@ fn c2010_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25165,13 +16154,7 @@ fn c2011_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25275,13 +16258,7 @@ fn c2024_l2036_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25289,13 +16266,7 @@ fn c2025_l2037_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25303,13 +16274,7 @@ fn c2026_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25317,13 +16282,7 @@ fn c2027_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25331,10 +16290,7 @@ fn c2028_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25366,13 +16322,7 @@ fn c2032_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25380,13 +16330,7 @@ fn c2033_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25394,13 +16338,7 @@ fn c2034_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25408,13 +16346,7 @@ fn c2035_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25422,10 +16354,7 @@ fn c2036_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25433,10 +16362,7 @@ fn c2037_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25444,10 +16370,7 @@ fn c2038_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25455,10 +16378,7 @@ fn c2039_l2051_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25466,13 +16386,7 @@ fn c2040_l2052_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25480,13 +16394,7 @@ fn c2041_l2053_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25494,13 +16402,7 @@ fn c2042_l2054_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25508,13 +16410,7 @@ fn c2043_l2055_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25522,13 +16418,7 @@ fn c2044_l2056_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25536,13 +16426,7 @@ fn c2045_l2057_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25550,13 +16434,7 @@ fn c2046_l2058_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25564,13 +16442,7 @@ fn c2047_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25578,13 +16450,7 @@ fn c2048_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25592,13 +16458,7 @@ fn c2049_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25606,13 +16466,7 @@ fn c2050_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25620,13 +16474,7 @@ fn c2051_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25634,13 +16482,7 @@ fn c2052_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25648,13 +16490,7 @@ fn c2053_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25662,13 +16498,7 @@ fn c2054_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25676,13 +16506,7 @@ fn c2055_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25690,13 +16514,7 @@ fn c2056_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25704,13 +16522,7 @@ fn c2057_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25718,13 +16530,7 @@ fn c2058_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25732,13 +16538,7 @@ fn c2059_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25746,13 +16546,7 @@ fn c2060_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25760,13 +16554,7 @@ fn c2061_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25774,13 +16562,7 @@ fn c2062_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25788,13 +16570,7 @@ fn c2063_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25802,13 +16578,7 @@ fn c2064_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25816,13 +16586,7 @@ fn c2065_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25830,13 +16594,7 @@ fn c2066_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25844,13 +16602,7 @@ fn c2067_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25858,13 +16610,7 @@ fn c2068_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25872,13 +16618,7 @@ fn c2069_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25886,13 +16626,7 @@ fn c2070_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -25900,13 +16634,7 @@ fn c2071_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25914,13 +16642,7 @@ fn c2072_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25928,13 +16650,7 @@ fn c2073_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25942,13 +16658,7 @@ fn c2074_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25956,13 +16666,7 @@ fn c2075_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25970,13 +16674,7 @@ fn c2076_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25984,13 +16682,7 @@ fn c2077_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -25998,13 +16690,7 @@ fn c2078_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26012,13 +16698,7 @@ fn c2079_l2091_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26026,13 +16706,7 @@ fn c2080_l2092_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26040,13 +16714,7 @@ fn c2081_l2093_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26054,13 +16722,7 @@ fn c2082_l2094_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26068,13 +16730,7 @@ fn c2083_l2095_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26082,13 +16738,7 @@ fn c2084_l2096_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26096,13 +16746,7 @@ fn c2085_l2097_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26110,13 +16754,7 @@ fn c2086_l2098_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26124,13 +16762,7 @@ fn c2087_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26138,13 +16770,7 @@ fn c2088_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26152,13 +16778,7 @@ fn c2089_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26166,13 +16786,7 @@ fn c2090_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26180,13 +16794,7 @@ fn c2091_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26194,13 +16802,7 @@ fn c2092_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26208,13 +16810,7 @@ fn c2093_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26222,13 +16818,7 @@ fn c2094_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26236,13 +16826,7 @@ fn c2095_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26250,13 +16834,7 @@ fn c2096_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26264,13 +16842,7 @@ fn c2097_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26278,13 +16850,7 @@ fn c2098_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26292,13 +16858,7 @@ fn c2099_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26306,13 +16866,7 @@ fn c2100_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26320,13 +16874,7 @@ fn c2101_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26334,13 +16882,7 @@ fn c2102_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26348,13 +16890,7 @@ fn c2103_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26362,13 +16898,7 @@ fn c2104_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26376,13 +16906,7 @@ fn c2105_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26390,13 +16914,7 @@ fn c2106_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26404,13 +16922,7 @@ fn c2107_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26418,13 +16930,7 @@ fn c2108_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26432,13 +16938,7 @@ fn c2109_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26446,13 +16946,7 @@ fn c2110_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26460,13 +16954,7 @@ fn c2111_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26474,13 +16962,7 @@ fn c2112_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26488,13 +16970,7 @@ fn c2113_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26502,13 +16978,7 @@ fn c2114_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26516,13 +16986,7 @@ fn c2115_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26530,13 +16994,7 @@ fn c2116_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26544,13 +17002,7 @@ fn c2117_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26558,13 +17010,7 @@ fn c2118_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26572,13 +17018,7 @@ fn c2119_l2131_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26618,13 +17058,7 @@ fn c2124_l2136_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26632,13 +17066,7 @@ fn c2125_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26646,13 +17074,7 @@ fn c2126_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26660,13 +17082,7 @@ fn c2127_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26674,13 +17090,7 @@ fn c2128_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26688,13 +17098,7 @@ fn c2129_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26702,13 +17106,7 @@ fn c2130_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26716,13 +17114,7 @@ fn c2131_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26826,13 +17218,7 @@ fn c2144_l2156_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26840,13 +17226,7 @@ fn c2145_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26854,13 +17234,7 @@ fn c2146_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26868,13 +17242,7 @@ fn c2147_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26882,10 +17250,7 @@ fn c2148_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -26917,13 +17282,7 @@ fn c2152_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26931,13 +17290,7 @@ fn c2153_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26945,13 +17298,7 @@ fn c2154_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26959,13 +17306,7 @@ fn c2155_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26973,10 +17314,7 @@ fn c2156_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26984,10 +17322,7 @@ fn c2157_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -26995,10 +17330,7 @@ fn c2158_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27006,10 +17338,7 @@ fn c2159_l2171_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27049,13 +17378,7 @@ fn c2164_l2176_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27063,13 +17386,7 @@ fn c2165_l2177_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27077,13 +17394,7 @@ fn c2166_l2178_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27091,13 +17402,7 @@ fn c2167_l2179_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27105,13 +17410,7 @@ fn c2168_l2180_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27119,13 +17418,7 @@ fn c2169_l2181_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27133,13 +17426,7 @@ fn c2170_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27147,13 +17434,7 @@ fn c2171_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27257,13 +17538,7 @@ fn c2184_l2196_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27271,13 +17546,7 @@ fn c2185_l2197_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27285,13 +17554,7 @@ fn c2186_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27299,13 +17562,7 @@ fn c2187_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27313,10 +17570,7 @@ fn c2188_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27348,13 +17602,7 @@ fn c2192_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27362,13 +17610,7 @@ fn c2193_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27376,13 +17618,7 @@ fn c2194_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27390,13 +17626,7 @@ fn c2195_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27404,10 +17634,7 @@ fn c2196_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4290772992))],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27415,10 +17642,7 @@ fn c2197_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(4288675840))],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27426,10 +17650,7 @@ fn c2198_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27437,10 +17658,7 @@ fn c2199_l2211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2141192192))],
-    );
+    let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27480,13 +17698,7 @@ fn c2204_l2216_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27494,13 +17706,7 @@ fn c2205_l2217_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27508,13 +17714,7 @@ fn c2206_l2218_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27522,13 +17722,7 @@ fn c2207_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27536,13 +17730,7 @@ fn c2208_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27550,13 +17738,7 @@ fn c2209_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27564,13 +17746,7 @@ fn c2210_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27578,13 +17754,7 @@ fn c2211_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27656,10 +17826,7 @@ fn c2220_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27667,10 +17834,7 @@ fn c2221_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27678,10 +17842,7 @@ fn c2222_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27689,10 +17850,7 @@ fn c2223_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27700,13 +17858,7 @@ fn c2224_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27714,13 +17866,7 @@ fn c2225_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27728,13 +17874,7 @@ fn c2226_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27742,13 +17882,7 @@ fn c2227_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27756,10 +17890,7 @@ fn c2228_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27767,10 +17898,7 @@ fn c2229_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27778,10 +17906,7 @@ fn c2230_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27789,10 +17914,7 @@ fn c2231_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27800,13 +17922,7 @@ fn c2232_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27814,13 +17930,7 @@ fn c2233_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27828,13 +17938,7 @@ fn c2234_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27842,13 +17946,7 @@ fn c2235_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27856,13 +17954,7 @@ fn c2236_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27870,13 +17962,7 @@ fn c2237_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27884,13 +17970,7 @@ fn c2238_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27898,13 +17978,7 @@ fn c2239_l2251_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27912,13 +17986,7 @@ fn c2240_l2252_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27926,13 +17994,7 @@ fn c2241_l2253_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27940,13 +18002,7 @@ fn c2242_l2254_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27954,13 +18010,7 @@ fn c2243_l2255_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -27968,13 +18018,7 @@ fn c2244_l2256_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27982,13 +18026,7 @@ fn c2245_l2257_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -27996,13 +18034,7 @@ fn c2246_l2258_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28010,13 +18042,7 @@ fn c2247_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28024,13 +18050,7 @@ fn c2248_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28038,13 +18058,7 @@ fn c2249_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28052,13 +18066,7 @@ fn c2250_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28066,13 +18074,7 @@ fn c2251_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28080,13 +18082,7 @@ fn c2252_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28094,13 +18090,7 @@ fn c2253_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28108,13 +18098,7 @@ fn c2254_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28122,13 +18106,7 @@ fn c2255_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28136,13 +18114,7 @@ fn c2256_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28150,13 +18122,7 @@ fn c2257_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28164,13 +18130,7 @@ fn c2258_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28178,13 +18138,7 @@ fn c2259_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28192,13 +18146,7 @@ fn c2260_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28206,13 +18154,7 @@ fn c2261_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28220,13 +18162,7 @@ fn c2262_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28234,13 +18170,7 @@ fn c2263_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28248,13 +18178,7 @@ fn c2264_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28262,13 +18186,7 @@ fn c2265_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28276,13 +18194,7 @@ fn c2266_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28290,13 +18202,7 @@ fn c2267_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28304,13 +18210,7 @@ fn c2268_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28318,13 +18218,7 @@ fn c2269_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28332,13 +18226,7 @@ fn c2270_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28346,13 +18234,7 @@ fn c2271_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28360,13 +18242,7 @@ fn c2272_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28374,13 +18250,7 @@ fn c2273_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28388,13 +18258,7 @@ fn c2274_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28402,13 +18266,7 @@ fn c2275_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28416,13 +18274,7 @@ fn c2276_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28430,13 +18282,7 @@ fn c2277_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28444,13 +18290,7 @@ fn c2278_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28458,13 +18298,7 @@ fn c2279_l2291_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28472,10 +18306,7 @@ fn c2280_l2292_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28507,13 +18338,7 @@ fn c2284_l2296_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28521,13 +18346,7 @@ fn c2285_l2297_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28535,13 +18354,7 @@ fn c2286_l2298_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28549,13 +18362,7 @@ fn c2287_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28563,13 +18370,7 @@ fn c2288_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28577,13 +18378,7 @@ fn c2289_l2301_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28591,13 +18386,7 @@ fn c2290_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28605,13 +18394,7 @@ fn c2291_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28619,10 +18402,7 @@ fn c2292_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-0.5f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28654,10 +18434,7 @@ fn c2296_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28689,10 +18466,7 @@ fn c2300_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28700,10 +18474,7 @@ fn c2301_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28711,10 +18482,7 @@ fn c2302_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((-6.2831855f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28722,10 +18490,7 @@ fn c2303_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((6.2831855f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28733,13 +18498,7 @@ fn c2304_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28747,13 +18506,7 @@ fn c2305_l2317_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28761,13 +18514,7 @@ fn c2306_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28775,13 +18522,7 @@ fn c2307_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28789,10 +18530,7 @@ fn c2308_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28800,10 +18538,7 @@ fn c2309_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28811,10 +18546,7 @@ fn c2310_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28822,10 +18554,7 @@ fn c2311_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32(f32::INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -28833,13 +18562,7 @@ fn c2312_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28847,13 +18570,7 @@ fn c2313_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28861,13 +18578,7 @@ fn c2314_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28875,13 +18586,7 @@ fn c2315_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28889,13 +18594,7 @@ fn c2316_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28903,13 +18602,7 @@ fn c2317_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28917,13 +18610,7 @@ fn c2318_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28931,13 +18618,7 @@ fn c2319_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28945,13 +18626,7 @@ fn c2320_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28959,13 +18634,7 @@ fn c2321_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28973,10 +18642,7 @@ fn c2322_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28984,10 +18650,7 @@ fn c2323_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -28995,13 +18658,7 @@ fn c2324_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29009,13 +18666,7 @@ fn c2325_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29023,10 +18674,7 @@ fn c2326_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29034,10 +18682,7 @@ fn c2327_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29045,13 +18690,7 @@ fn c2328_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29059,13 +18698,7 @@ fn c2329_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29073,13 +18706,7 @@ fn c2330_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29087,13 +18714,7 @@ fn c2331_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29101,13 +18722,7 @@ fn c2332_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29115,13 +18730,7 @@ fn c2333_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29129,13 +18738,7 @@ fn c2334_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29143,13 +18746,7 @@ fn c2335_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000001f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29157,13 +18754,7 @@ fn c2336_l2348_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29171,13 +18762,7 @@ fn c2337_l2349_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29185,13 +18770,7 @@ fn c2338_l2350_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29199,13 +18778,7 @@ fn c2339_l2351_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29213,13 +18786,7 @@ fn c2340_l2352_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29227,13 +18794,7 @@ fn c2341_l2353_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29241,13 +18802,7 @@ fn c2342_l2354_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29255,13 +18810,7 @@ fn c2343_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29269,13 +18818,7 @@ fn c2344_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29283,13 +18826,7 @@ fn c2345_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29297,10 +18834,7 @@ fn c2346_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29308,10 +18842,7 @@ fn c2347_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29319,13 +18850,7 @@ fn c2348_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29333,13 +18858,7 @@ fn c2349_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.5f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29347,10 +18866,7 @@ fn c2350_l2362_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29358,10 +18874,7 @@ fn c2351_l2363_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29369,13 +18882,7 @@ fn c2352_l2364_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29383,13 +18890,7 @@ fn c2353_l2365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29397,10 +18898,7 @@ fn c2354_l2366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29408,10 +18906,7 @@ fn c2355_l2367_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29419,13 +18914,7 @@ fn c2356_l2368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29433,13 +18922,7 @@ fn c2357_l2369_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29447,10 +18930,7 @@ fn c2358_l2370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29458,10 +18938,7 @@ fn c2359_l2371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29469,13 +18946,7 @@ fn c2360_l2372_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29483,13 +18954,7 @@ fn c2361_l2373_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29497,13 +18962,7 @@ fn c2362_l2374_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29511,13 +18970,7 @@ fn c2363_l2375_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29525,13 +18978,7 @@ fn c2364_l2376_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29539,13 +18986,7 @@ fn c2365_l2377_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29553,13 +18994,7 @@ fn c2366_l2378_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29567,13 +19002,7 @@ fn c2367_l2379_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6.2831855f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29581,13 +19010,7 @@ fn c2368_l2380_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29595,13 +19018,7 @@ fn c2369_l2381_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29609,13 +19026,7 @@ fn c2370_l2382_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29623,13 +19034,7 @@ fn c2371_l2383_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29637,13 +19042,7 @@ fn c2372_l2384_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29651,13 +19050,7 @@ fn c2373_l2385_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29665,13 +19058,7 @@ fn c2374_l2386_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29679,13 +19066,7 @@ fn c2375_l2387_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29693,13 +19074,7 @@ fn c2376_l2388_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29707,13 +19082,7 @@ fn c2377_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29721,13 +19090,7 @@ fn c2378_l2390_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29735,13 +19098,7 @@ fn c2379_l2391_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29749,13 +19106,7 @@ fn c2380_l2392_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29763,13 +19114,7 @@ fn c2381_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29777,13 +19122,7 @@ fn c2382_l2394_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29791,13 +19130,7 @@ fn c2383_l2395_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29805,13 +19138,7 @@ fn c2384_l2396_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29819,13 +19146,7 @@ fn c2385_l2397_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29833,13 +19154,7 @@ fn c2386_l2398_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29847,13 +19162,7 @@ fn c2387_l2399_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29861,13 +19170,7 @@ fn c2388_l2400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29875,13 +19178,7 @@ fn c2389_l2401_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29889,13 +19186,7 @@ fn c2390_l2402_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29903,13 +19194,7 @@ fn c2391_l2403_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29917,13 +19202,7 @@ fn c2392_l2404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29931,13 +19210,7 @@ fn c2393_l2405_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29945,13 +19218,7 @@ fn c2394_l2406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29959,13 +19226,7 @@ fn c2395_l2407_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(4288675840)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29973,13 +19234,7 @@ fn c2396_l2408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -29987,13 +19242,7 @@ fn c2397_l2409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -30001,13 +19250,7 @@ fn c2398_l2410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -30015,13 +19258,7 @@ fn c2399_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2141192192)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
diff --git a/lib/runtime/tests/spectests/f64_.rs b/lib/runtime/tests/spectests/f64_.rs
index b28418b9a..02e3960d7 100644
--- a/lib/runtime/tests/spectests/f64_.rs
+++ b/lib/runtime/tests/spectests/f64_.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 5
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64 f64) (result f64)))
       (type (;1;) (func (param f64) (result f64)))
@@ -71,11 +75,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -246,10 +247,7 @@ fn c20_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -257,10 +255,7 @@ fn c21_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -268,10 +263,7 @@ fn c22_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -279,10 +271,7 @@ fn c23_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -322,10 +311,7 @@ fn c28_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -341,10 +327,7 @@ fn c30_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -359,185 +342,89 @@ fn c32_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c33_l51_assert_return_canonical_nan");
+    println!("Executing function {}", "c33_l51_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c33_l51_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c34_l52_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c34_l52_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c34_l52_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c35_l53_assert_return_canonical_nan");
+    println!("Executing function {}", "c35_l53_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c35_l53_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c36_l54_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c36_l54_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c36_l54_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c37_l55_assert_return_canonical_nan");
+    println!("Executing function {}", "c37_l55_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c37_l55_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c38_l56_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c38_l56_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c38_l56_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c39_l57_assert_return_canonical_nan");
+    println!("Executing function {}", "c39_l57_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c39_l57_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c40_l58_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c40_l58_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c40_l58_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -799,113 +686,89 @@ fn c72_l90_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 91
 fn c73_l91_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c73_l91_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c73_l91_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c73_l91_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 92
 fn c74_l92_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c74_l92_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c74_l92_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c74_l92_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 93
 fn c75_l93_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c75_l93_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c75_l93_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c75_l93_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 94
 fn c76_l94_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c76_l94_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c76_l94_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c76_l94_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 95
 fn c77_l95_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c77_l95_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c77_l95_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c77_l95_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 96
 fn c78_l96_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c78_l96_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c78_l96_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c78_l96_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 97
 fn c79_l97_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c79_l97_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c79_l97_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c79_l97_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 98
 fn c80_l98_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c80_l98_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c80_l98_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c80_l98_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1167,113 +1030,89 @@ fn c112_l130_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 131
 fn c113_l131_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c113_l131_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c113_l131_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c113_l131_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 132
 fn c114_l132_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c114_l132_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c114_l132_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c114_l132_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 133
 fn c115_l133_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c115_l133_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c115_l133_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c115_l133_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 134
 fn c116_l134_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c116_l134_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c116_l134_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c116_l134_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 135
 fn c117_l135_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c117_l135_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c117_l135_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c117_l135_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 136
 fn c118_l136_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c118_l136_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c118_l136_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c118_l136_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 137
 fn c119_l137_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c119_l137_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c119_l137_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c119_l137_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 138
 fn c120_l138_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c120_l138_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c120_l138_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c120_l138_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1440,10 +1279,7 @@ fn c140_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -1451,10 +1287,7 @@ fn c141_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -1462,10 +1295,7 @@ fn c142_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -1473,10 +1303,7 @@ fn c143_l161_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -1516,10 +1343,7 @@ fn c148_l166_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -1535,10 +1359,7 @@ fn c150_l168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -1553,185 +1374,89 @@ fn c152_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c153_l171_assert_return_canonical_nan");
+    println!("Executing function {}", "c153_l171_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c153_l171_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c154_l172_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c154_l172_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c154_l172_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c155_l173_assert_return_canonical_nan");
+    println!("Executing function {}", "c155_l173_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c155_l173_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c156_l174_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c156_l174_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c156_l174_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c157_l175_assert_return_canonical_nan");
+    println!("Executing function {}", "c157_l175_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c157_l175_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c158_l176_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c158_l176_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c158_l176_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c159_l177_assert_return_canonical_nan");
+    println!("Executing function {}", "c159_l177_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c159_l177_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c160_l178_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c160_l178_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c160_l178_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1898,10 +1623,7 @@ fn c180_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1909,10 +1631,7 @@ fn c181_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1920,10 +1639,7 @@ fn c182_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1931,10 +1647,7 @@ fn c183_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1974,10 +1687,7 @@ fn c188_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -1993,10 +1703,7 @@ fn c190_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2011,195 +1718,96 @@ fn c192_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c193_l211_assert_return_canonical_nan");
+    println!("Executing function {}", "c193_l211_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c193_l211_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c194_l212_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c194_l212_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c194_l212_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c195_l213_assert_return_canonical_nan");
+    println!("Executing function {}", "c195_l213_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c195_l213_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c196_l214_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c196_l214_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c196_l214_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c197_l215_assert_return_canonical_nan");
+    println!("Executing function {}", "c197_l215_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c197_l215_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c198_l216_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c198_l216_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c198_l216_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c199_l217_assert_return_canonical_nan");
+    println!("Executing function {}", "c199_l217_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c199_l217_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c200_l218_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c200_l218_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c200_l218_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2207,10 +1815,7 @@ fn c201_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2218,10 +1823,7 @@ fn c202_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2229,10 +1831,7 @@ fn c203_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2304,10 +1903,7 @@ fn c212_l230_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -2315,10 +1911,7 @@ fn c213_l231_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -2326,10 +1919,7 @@ fn c214_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -2337,10 +1927,7 @@ fn c215_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -2348,10 +1935,7 @@ fn c216_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2359,10 +1943,7 @@ fn c217_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2370,10 +1951,7 @@ fn c218_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2381,10 +1959,7 @@ fn c219_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2392,13 +1967,7 @@ fn c220_l238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64)))));
     result.map(|_| ())
 }
@@ -2406,13 +1975,7 @@ fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -2420,13 +1983,7 @@ fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -2434,13 +1991,7 @@ fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64)))));
     result.map(|_| ())
 }
@@ -2480,13 +2031,7 @@ fn c228_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2494,13 +2039,7 @@ fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2508,13 +2047,7 @@ fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2522,198 +2055,96 @@ fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c233_l251_assert_return_canonical_nan");
+    println!("Executing function {}", "c233_l251_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c233_l251_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c234_l252_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c234_l252_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c234_l252_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c235_l253_assert_return_canonical_nan");
+    println!("Executing function {}", "c235_l253_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c235_l253_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c236_l254_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c236_l254_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c236_l254_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c237_l255_assert_return_canonical_nan");
+    println!("Executing function {}", "c237_l255_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c237_l255_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c238_l256_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c238_l256_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c238_l256_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c239_l257_assert_return_canonical_nan");
+    println!("Executing function {}", "c239_l257_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c239_l257_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c240_l258_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c240_l258_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c240_l258_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -2975,123 +2406,96 @@ fn c272_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 291
 fn c273_l291_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c273_l291_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c273_l291_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c273_l291_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 292
 fn c274_l292_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c274_l292_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c274_l292_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c274_l292_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 293
 fn c275_l293_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c275_l293_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c275_l293_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c275_l293_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 294
 fn c276_l294_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c276_l294_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c276_l294_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c276_l294_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 295
 fn c277_l295_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c277_l295_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c277_l295_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c277_l295_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 296
 fn c278_l296_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c278_l296_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c278_l296_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c278_l296_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 297
 fn c279_l297_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c279_l297_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c279_l297_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c279_l297_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 298
 fn c280_l298_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c280_l298_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c280_l298_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c280_l298_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3099,10 +2503,7 @@ fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3190,10 +2591,7 @@ fn c292_l310_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3201,10 +2599,7 @@ fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.5f64))],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3228,10 +2623,7 @@ fn c296_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3239,10 +2631,7 @@ fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((1.0f64))],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3266,13 +2655,7 @@ fn c300_l318_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3280,13 +2663,7 @@ fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -3294,13 +2671,7 @@ fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -3308,13 +2679,7 @@ fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -3354,1870 +2719,1006 @@ fn c308_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     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), Value::F64(f64::INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c310_l328_assert_return_canonical_nan");
+    println!("Executing function {}", "c310_l328_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c310_l328_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64(f64::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c311_l329_assert_return_canonical_nan");
+    println!("Executing function {}", "c311_l329_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c311_l329_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c313_l331_assert_return_canonical_nan");
+    println!("Executing function {}", "c313_l331_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c313_l331_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c314_l332_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c314_l332_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c314_l332_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c315_l333_assert_return_canonical_nan");
+    println!("Executing function {}", "c315_l333_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c315_l333_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c316_l334_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c316_l334_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c316_l334_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c317_l335_assert_return_canonical_nan");
+    println!("Executing function {}", "c317_l335_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c317_l335_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c318_l336_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c318_l336_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c318_l336_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c319_l337_assert_return_canonical_nan");
+    println!("Executing function {}", "c319_l337_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c319_l337_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c320_l338_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c320_l338_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c320_l338_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c321_l339_assert_return_canonical_nan");
+    println!("Executing function {}", "c321_l339_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c321_l339_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c322_l340_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c322_l340_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c322_l340_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c323_l341_assert_return_canonical_nan");
+    println!("Executing function {}", "c323_l341_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c323_l341_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c324_l342_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c324_l342_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c324_l342_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c325_l343_assert_return_canonical_nan");
+    println!("Executing function {}", "c325_l343_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c325_l343_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c326_l344_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c326_l344_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c326_l344_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c327_l345_assert_return_canonical_nan");
+    println!("Executing function {}", "c327_l345_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c327_l345_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c328_l346_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c328_l346_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c328_l346_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 347
 fn c329_l347_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c329_l347_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c329_l347_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c329_l347_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 348
 fn c330_l348_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c330_l348_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c330_l348_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c330_l348_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 349
 fn c331_l349_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c331_l349_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c331_l349_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c331_l349_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 350
 fn c332_l350_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c332_l350_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c332_l350_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c332_l350_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 351
 fn c333_l351_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c333_l351_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c333_l351_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c333_l351_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 352
 fn c334_l352_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c334_l352_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c334_l352_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c334_l352_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 353
 fn c335_l353_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c335_l353_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c335_l353_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c335_l353_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 354
 fn c336_l354_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c336_l354_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c336_l354_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c336_l354_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 355
 fn c337_l355_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c337_l355_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c337_l355_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c337_l355_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 356
 fn c338_l356_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c338_l356_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c338_l356_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c338_l356_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 357
 fn c339_l357_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c339_l357_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c339_l357_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c339_l357_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 358
 fn c340_l358_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c340_l358_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c340_l358_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c340_l358_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 359
 fn c341_l359_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c341_l359_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c341_l359_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c341_l359_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 360
 fn c342_l360_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c342_l360_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c342_l360_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c342_l360_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 361
 fn c343_l361_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c343_l361_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c343_l361_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c343_l361_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 362
 fn c344_l362_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c344_l362_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c344_l362_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c344_l362_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c345_l363_assert_return_canonical_nan");
+    println!("Executing function {}", "c345_l363_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c345_l363_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c346_l364_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c346_l364_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c346_l364_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c347_l365_assert_return_canonical_nan");
+    println!("Executing function {}", "c347_l365_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c347_l365_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c348_l366_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c348_l366_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c348_l366_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c349_l367_assert_return_canonical_nan");
+    println!("Executing function {}", "c349_l367_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c349_l367_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c350_l368_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c350_l368_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c350_l368_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c351_l369_assert_return_canonical_nan");
+    println!("Executing function {}", "c351_l369_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c351_l369_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c352_l370_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c352_l370_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c352_l370_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c353_l371_assert_return_canonical_nan");
+    println!("Executing function {}", "c353_l371_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c353_l371_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c354_l372_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c354_l372_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c354_l372_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c355_l373_assert_return_canonical_nan");
+    println!("Executing function {}", "c355_l373_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c355_l373_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c356_l374_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c356_l374_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c356_l374_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c357_l375_assert_return_canonical_nan");
+    println!("Executing function {}", "c357_l375_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c357_l375_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c358_l376_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c358_l376_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c358_l376_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c359_l377_assert_return_canonical_nan");
+    println!("Executing function {}", "c359_l377_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c359_l377_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c360_l378_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c360_l378_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c360_l378_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c361_l379_assert_return_canonical_nan");
+    println!("Executing function {}", "c361_l379_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c361_l379_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c362_l380_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c362_l380_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c362_l380_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c363_l381_assert_return_canonical_nan");
+    println!("Executing function {}", "c363_l381_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c363_l381_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c364_l382_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c364_l382_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c364_l382_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c365_l383_assert_return_canonical_nan");
+    println!("Executing function {}", "c365_l383_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c365_l383_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c366_l384_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c366_l384_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c366_l384_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c367_l385_assert_return_canonical_nan");
+    println!("Executing function {}", "c367_l385_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c367_l385_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c368_l386_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c368_l386_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c368_l386_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 387
 fn c369_l387_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c369_l387_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c369_l387_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c369_l387_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 388
 fn c370_l388_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c370_l388_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c370_l388_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c370_l388_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 389
 fn c371_l389_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c371_l389_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c371_l389_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c371_l389_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 390
 fn c372_l390_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c372_l390_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c372_l390_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c372_l390_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 391
 fn c373_l391_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c373_l391_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c373_l391_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c373_l391_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 392
 fn c374_l392_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c374_l392_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c374_l392_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c374_l392_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 393
 fn c375_l393_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c375_l393_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c375_l393_assert_return_canonical_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c375_l393_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 394
 fn c376_l394_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c376_l394_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c376_l394_assert_return_arithmetic_nan");
     let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c376_l394_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c377_l395_assert_return_canonical_nan");
+    println!("Executing function {}", "c377_l395_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c377_l395_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c378_l396_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c378_l396_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c378_l396_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c379_l397_assert_return_canonical_nan");
+    println!("Executing function {}", "c379_l397_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c379_l397_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c380_l398_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c380_l398_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c380_l398_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c381_l399_assert_return_canonical_nan");
+    println!("Executing function {}", "c381_l399_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c381_l399_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c382_l400_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c382_l400_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c382_l400_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c383_l401_assert_return_canonical_nan");
+    println!("Executing function {}", "c383_l401_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c383_l401_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c384_l402_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c384_l402_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c384_l402_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c385_l403_assert_return_canonical_nan");
+    println!("Executing function {}", "c385_l403_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c385_l403_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c386_l404_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c386_l404_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c386_l404_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c387_l405_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c387_l405_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c387_l405_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c388_l406_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c388_l406_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c388_l406_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c389_l407_assert_return_canonical_nan");
+    println!("Executing function {}", "c389_l407_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c389_l407_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c390_l408_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c390_l408_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c390_l408_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c391_l409_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c391_l409_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c391_l409_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c392_l410_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c392_l410_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c392_l410_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c393_l411_assert_return_canonical_nan");
+    println!("Executing function {}", "c393_l411_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c393_l411_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c394_l412_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c394_l412_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c394_l412_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c395_l413_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c395_l413_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c395_l413_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c396_l414_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c396_l414_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c396_l414_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c397_l415_assert_return_canonical_nan");
+    println!("Executing function {}", "c397_l415_assert_return_canonical_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c397_l415_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c398_l416_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c398_l416_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c398_l416_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c399_l417_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c399_l417_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c399_l417_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c400_l418_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c400_l418_assert_return_arithmetic_nan");
+    let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c400_l418_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -5384,10 +3885,7 @@ fn c420_l438_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -5395,10 +3893,7 @@ fn c421_l439_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -5406,10 +3901,7 @@ fn c422_l440_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -5417,10 +3909,7 @@ fn c423_l441_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -5460,10 +3949,7 @@ fn c428_l446_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -5479,10 +3965,7 @@ fn c430_l448_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -5497,185 +3980,89 @@ fn c432_l450_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c433_l451_assert_return_canonical_nan");
+    println!("Executing function {}", "c433_l451_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c433_l451_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c434_l452_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c434_l452_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c434_l452_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c435_l453_assert_return_canonical_nan");
+    println!("Executing function {}", "c435_l453_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c435_l453_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c436_l454_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c436_l454_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c436_l454_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c437_l455_assert_return_canonical_nan");
+    println!("Executing function {}", "c437_l455_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c437_l455_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c438_l456_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c438_l456_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c438_l456_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c439_l457_assert_return_canonical_nan");
+    println!("Executing function {}", "c439_l457_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c439_l457_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c440_l458_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c440_l458_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c440_l458_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -5937,113 +4324,89 @@ fn c472_l490_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 491
 fn c473_l491_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c473_l491_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c473_l491_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c473_l491_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 492
 fn c474_l492_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c474_l492_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c474_l492_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c474_l492_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 493
 fn c475_l493_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c475_l493_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c475_l493_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c475_l493_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 494
 fn c476_l494_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c476_l494_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c476_l494_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c476_l494_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 495
 fn c477_l495_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c477_l495_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c477_l495_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c477_l495_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 496
 fn c478_l496_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c478_l496_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c478_l496_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c478_l496_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 497
 fn c479_l497_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c479_l497_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c479_l497_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c479_l497_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 498
 fn c480_l498_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c480_l498_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c480_l498_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c480_l498_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -6305,113 +4668,89 @@ fn c512_l530_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 531
 fn c513_l531_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c513_l531_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c513_l531_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c513_l531_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 532
 fn c514_l532_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c514_l532_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c514_l532_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c514_l532_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 533
 fn c515_l533_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c515_l533_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c515_l533_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c515_l533_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 534
 fn c516_l534_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c516_l534_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c516_l534_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c516_l534_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 535
 fn c517_l535_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c517_l535_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c517_l535_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c517_l535_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 536
 fn c518_l536_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c518_l536_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c518_l536_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c518_l536_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 537
 fn c519_l537_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c519_l537_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c519_l537_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c519_l537_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 538
 fn c520_l538_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c520_l538_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c520_l538_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c520_l538_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -6578,10 +4917,7 @@ fn c540_l558_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -6589,10 +4925,7 @@ fn c541_l559_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -6600,10 +4933,7 @@ fn c542_l560_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -6611,10 +4941,7 @@ fn c543_l561_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -6654,10 +4981,7 @@ fn c548_l566_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -6673,10 +4997,7 @@ fn c550_l568_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -6691,185 +5012,89 @@ fn c552_l570_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c553_l571_assert_return_canonical_nan");
+    println!("Executing function {}", "c553_l571_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c553_l571_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c554_l572_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c554_l572_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c554_l572_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c555_l573_assert_return_canonical_nan");
+    println!("Executing function {}", "c555_l573_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c555_l573_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c556_l574_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c556_l574_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c556_l574_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c557_l575_assert_return_canonical_nan");
+    println!("Executing function {}", "c557_l575_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c557_l575_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c558_l576_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c558_l576_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c558_l576_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c559_l577_assert_return_canonical_nan");
+    println!("Executing function {}", "c559_l577_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c559_l577_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c560_l578_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c560_l578_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c560_l578_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -7036,10 +5261,7 @@ fn c580_l598_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7047,10 +5269,7 @@ fn c581_l599_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7058,10 +5277,7 @@ fn c582_l600_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7069,10 +5285,7 @@ fn c583_l601_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7112,10 +5325,7 @@ fn c588_l606_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -7131,10 +5341,7 @@ fn c590_l608_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -7149,195 +5356,96 @@ fn c592_l610_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c593_l611_assert_return_canonical_nan");
+    println!("Executing function {}", "c593_l611_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c593_l611_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c594_l612_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c594_l612_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c594_l612_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c595_l613_assert_return_canonical_nan");
+    println!("Executing function {}", "c595_l613_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c595_l613_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c596_l614_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c596_l614_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c596_l614_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c597_l615_assert_return_canonical_nan");
+    println!("Executing function {}", "c597_l615_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c597_l615_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c598_l616_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c598_l616_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c598_l616_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c599_l617_assert_return_canonical_nan");
+    println!("Executing function {}", "c599_l617_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c599_l617_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c600_l618_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c600_l618_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c600_l618_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7345,10 +5453,7 @@ fn c601_l619_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7356,10 +5461,7 @@ fn c602_l620_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7367,10 +5469,7 @@ fn c603_l621_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7442,10 +5541,7 @@ fn c612_l630_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -7453,10 +5549,7 @@ fn c613_l631_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -7464,10 +5557,7 @@ fn c614_l632_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -7475,10 +5565,7 @@ fn c615_l633_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64)))));
     result.map(|_| ())
 }
@@ -7486,10 +5573,7 @@ fn c616_l634_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7497,10 +5581,7 @@ fn c617_l635_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7508,10 +5589,7 @@ fn c618_l636_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7519,10 +5597,7 @@ fn c619_l637_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -7530,13 +5605,7 @@ fn c620_l638_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7544,13 +5613,7 @@ fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64)))));
     result.map(|_| ())
 }
@@ -7558,13 +5621,7 @@ fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64)))));
     result.map(|_| ())
 }
@@ -7572,13 +5629,7 @@ fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7618,13 +5669,7 @@ fn c628_l646_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -7632,13 +5677,7 @@ fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -7646,13 +5685,7 @@ fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -7660,198 +5693,96 @@ fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c633_l651_assert_return_canonical_nan");
+    println!("Executing function {}", "c633_l651_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c633_l651_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c634_l652_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c634_l652_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c634_l652_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c635_l653_assert_return_canonical_nan");
+    println!("Executing function {}", "c635_l653_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c635_l653_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c636_l654_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c636_l654_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c636_l654_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c637_l655_assert_return_canonical_nan");
+    println!("Executing function {}", "c637_l655_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c637_l655_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c638_l656_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c638_l656_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c638_l656_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c639_l657_assert_return_canonical_nan");
+    println!("Executing function {}", "c639_l657_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c639_l657_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c640_l658_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c640_l658_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c640_l658_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -8113,123 +6044,96 @@ fn c672_l690_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 691
 fn c673_l691_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c673_l691_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c673_l691_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c673_l691_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 692
 fn c674_l692_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c674_l692_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c674_l692_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c674_l692_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 693
 fn c675_l693_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c675_l693_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c675_l693_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c675_l693_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 694
 fn c676_l694_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c676_l694_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c676_l694_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c676_l694_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 695
 fn c677_l695_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c677_l695_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c677_l695_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c677_l695_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 696
 fn c678_l696_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c678_l696_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c678_l696_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c678_l696_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 697
 fn c679_l697_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c679_l697_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c679_l697_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c679_l697_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 698
 fn c680_l698_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c680_l698_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c680_l698_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c680_l698_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8237,10 +6141,7 @@ fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8328,10 +6229,7 @@ fn c692_l710_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8339,10 +6237,7 @@ fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.5f64))],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8366,10 +6261,7 @@ fn c696_l714_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8377,10 +6269,7 @@ fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((1.0f64))],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8404,13 +6293,7 @@ fn c700_l718_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8418,13 +6301,7 @@ fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8432,13 +6309,7 @@ fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -8446,13 +6317,7 @@ fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -8491,31 +6356,19 @@ fn c708_l726_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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), Value::F64(f64::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c709_l727_assert_return_canonical_nan");
+    println!("Executing function {}", "c709_l727_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c709_l727_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -8523,1839 +6376,987 @@ fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     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), Value::F64(f64::INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c712_l730_assert_return_canonical_nan");
+    println!("Executing function {}", "c712_l730_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c712_l730_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c713_l731_assert_return_canonical_nan");
+    println!("Executing function {}", "c713_l731_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c713_l731_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c714_l732_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c714_l732_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c714_l732_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c715_l733_assert_return_canonical_nan");
+    println!("Executing function {}", "c715_l733_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c715_l733_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c716_l734_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c716_l734_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c716_l734_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c717_l735_assert_return_canonical_nan");
+    println!("Executing function {}", "c717_l735_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c717_l735_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c718_l736_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c718_l736_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c718_l736_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c719_l737_assert_return_canonical_nan");
+    println!("Executing function {}", "c719_l737_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c719_l737_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c720_l738_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c720_l738_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c720_l738_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c721_l739_assert_return_canonical_nan");
+    println!("Executing function {}", "c721_l739_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c721_l739_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c722_l740_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c722_l740_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c722_l740_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c723_l741_assert_return_canonical_nan");
+    println!("Executing function {}", "c723_l741_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c723_l741_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c724_l742_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c724_l742_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c724_l742_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c725_l743_assert_return_canonical_nan");
+    println!("Executing function {}", "c725_l743_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c725_l743_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c726_l744_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c726_l744_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c726_l744_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c727_l745_assert_return_canonical_nan");
+    println!("Executing function {}", "c727_l745_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c727_l745_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c728_l746_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c728_l746_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c728_l746_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 747
 fn c729_l747_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c729_l747_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c729_l747_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c729_l747_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 748
 fn c730_l748_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c730_l748_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c730_l748_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c730_l748_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 749
 fn c731_l749_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c731_l749_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c731_l749_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c731_l749_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 750
 fn c732_l750_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c732_l750_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c732_l750_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c732_l750_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 751
 fn c733_l751_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c733_l751_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c733_l751_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c733_l751_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 752
 fn c734_l752_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c734_l752_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c734_l752_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c734_l752_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 753
 fn c735_l753_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c735_l753_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c735_l753_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c735_l753_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 754
 fn c736_l754_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c736_l754_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c736_l754_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c736_l754_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 755
 fn c737_l755_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c737_l755_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c737_l755_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c737_l755_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 756
 fn c738_l756_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c738_l756_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c738_l756_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c738_l756_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 757
 fn c739_l757_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c739_l757_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c739_l757_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c739_l757_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 758
 fn c740_l758_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c740_l758_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c740_l758_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c740_l758_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 759
 fn c741_l759_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c741_l759_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c741_l759_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c741_l759_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 760
 fn c742_l760_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c742_l760_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c742_l760_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c742_l760_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 761
 fn c743_l761_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c743_l761_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c743_l761_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c743_l761_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 762
 fn c744_l762_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c744_l762_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c744_l762_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c744_l762_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c745_l763_assert_return_canonical_nan");
+    println!("Executing function {}", "c745_l763_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c745_l763_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c746_l764_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c746_l764_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c746_l764_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c747_l765_assert_return_canonical_nan");
+    println!("Executing function {}", "c747_l765_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c747_l765_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c748_l766_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c748_l766_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c748_l766_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c749_l767_assert_return_canonical_nan");
+    println!("Executing function {}", "c749_l767_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c749_l767_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c750_l768_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c750_l768_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c750_l768_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c751_l769_assert_return_canonical_nan");
+    println!("Executing function {}", "c751_l769_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c751_l769_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c752_l770_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c752_l770_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c752_l770_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c753_l771_assert_return_canonical_nan");
+    println!("Executing function {}", "c753_l771_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c753_l771_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c754_l772_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c754_l772_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c754_l772_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c755_l773_assert_return_canonical_nan");
+    println!("Executing function {}", "c755_l773_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c755_l773_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c756_l774_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c756_l774_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c756_l774_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c757_l775_assert_return_canonical_nan");
+    println!("Executing function {}", "c757_l775_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c757_l775_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c758_l776_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c758_l776_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c758_l776_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c759_l777_assert_return_canonical_nan");
+    println!("Executing function {}", "c759_l777_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c759_l777_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c760_l778_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c760_l778_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c760_l778_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c761_l779_assert_return_canonical_nan");
+    println!("Executing function {}", "c761_l779_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c761_l779_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c762_l780_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c762_l780_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c762_l780_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c763_l781_assert_return_canonical_nan");
+    println!("Executing function {}", "c763_l781_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c763_l781_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c764_l782_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c764_l782_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c764_l782_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c765_l783_assert_return_canonical_nan");
+    println!("Executing function {}", "c765_l783_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c765_l783_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c766_l784_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c766_l784_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c766_l784_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c767_l785_assert_return_canonical_nan");
+    println!("Executing function {}", "c767_l785_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c767_l785_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c768_l786_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c768_l786_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c768_l786_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 787
 fn c769_l787_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c769_l787_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c769_l787_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c769_l787_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 788
 fn c770_l788_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c770_l788_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c770_l788_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c770_l788_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 789
 fn c771_l789_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c771_l789_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c771_l789_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c771_l789_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 790
 fn c772_l790_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c772_l790_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c772_l790_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c772_l790_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 791
 fn c773_l791_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c773_l791_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c773_l791_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c773_l791_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 792
 fn c774_l792_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c774_l792_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c774_l792_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c774_l792_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 793
 fn c775_l793_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c775_l793_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c775_l793_assert_return_canonical_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c775_l793_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 794
 fn c776_l794_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c776_l794_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c776_l794_assert_return_arithmetic_nan");
     let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c776_l794_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c777_l795_assert_return_canonical_nan");
+    println!("Executing function {}", "c777_l795_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c777_l795_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c778_l796_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c778_l796_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c778_l796_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c779_l797_assert_return_canonical_nan");
+    println!("Executing function {}", "c779_l797_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c779_l797_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c780_l798_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c780_l798_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c780_l798_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c781_l799_assert_return_canonical_nan");
+    println!("Executing function {}", "c781_l799_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c781_l799_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c782_l800_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c782_l800_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c782_l800_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c783_l801_assert_return_canonical_nan");
+    println!("Executing function {}", "c783_l801_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c783_l801_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c784_l802_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c784_l802_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c784_l802_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c785_l803_assert_return_canonical_nan");
+    println!("Executing function {}", "c785_l803_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c785_l803_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c786_l804_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c786_l804_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c786_l804_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c787_l805_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c787_l805_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c787_l805_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c788_l806_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c788_l806_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c788_l806_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c789_l807_assert_return_canonical_nan");
+    println!("Executing function {}", "c789_l807_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c789_l807_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c790_l808_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c790_l808_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c790_l808_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c791_l809_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c791_l809_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c791_l809_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c792_l810_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c792_l810_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c792_l810_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c793_l811_assert_return_canonical_nan");
+    println!("Executing function {}", "c793_l811_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c793_l811_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c794_l812_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c794_l812_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c794_l812_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c795_l813_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c795_l813_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c795_l813_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c796_l814_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c796_l814_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c796_l814_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c797_l815_assert_return_canonical_nan");
+    println!("Executing function {}", "c797_l815_assert_return_canonical_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c797_l815_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c798_l816_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c798_l816_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c798_l816_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c799_l817_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c799_l817_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c799_l817_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c800_l818_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c800_l818_assert_return_arithmetic_nan");
+    let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c800_l818_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -10522,10 +7523,7 @@ fn c820_l838_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -10533,10 +7531,7 @@ fn c821_l839_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -10544,10 +7539,7 @@ fn c822_l840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -10555,10 +7547,7 @@ fn c823_l841_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -10597,259 +7586,133 @@ fn c828_l846_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)), Value::F64(f64::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c829_l847_assert_return_canonical_nan");
+    println!("Executing function {}", "c829_l847_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c829_l847_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64(f64::INFINITY)])
-        .unwrap()
-        .expect("Missing result in c830_l848_assert_return_canonical_nan");
+    println!("Executing function {}", "c830_l848_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c830_l848_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64(f64::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c831_l849_assert_return_canonical_nan");
+    println!("Executing function {}", "c831_l849_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c831_l849_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64(f64::INFINITY)])
-        .unwrap()
-        .expect("Missing result in c832_l850_assert_return_canonical_nan");
+    println!("Executing function {}", "c832_l850_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c832_l850_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c833_l851_assert_return_canonical_nan");
+    println!("Executing function {}", "c833_l851_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c833_l851_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c834_l852_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c834_l852_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c834_l852_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c835_l853_assert_return_canonical_nan");
+    println!("Executing function {}", "c835_l853_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c835_l853_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c836_l854_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c836_l854_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c836_l854_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c837_l855_assert_return_canonical_nan");
+    println!("Executing function {}", "c837_l855_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c837_l855_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c838_l856_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c838_l856_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c838_l856_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c839_l857_assert_return_canonical_nan");
+    println!("Executing function {}", "c839_l857_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c839_l857_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c840_l858_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c840_l858_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c840_l858_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -11049,10 +7912,7 @@ fn c864_l882_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.0000000000000008881784197001251f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64)))));
     result.map(|_| ())
 }
 
@@ -11060,10 +7920,7 @@ fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000000008881784197001251f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64)))));
     result.map(|_| ())
 }
 
@@ -11071,10 +7928,7 @@ fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000000008881784197001251f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64)))));
     result.map(|_| ())
 }
 
@@ -11082,10 +7936,7 @@ fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.0000000000000008881784197001251f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64)))));
     result.map(|_| ())
 }
 
@@ -11123,113 +7974,89 @@ fn c872_l890_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 891
 fn c873_l891_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c873_l891_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c873_l891_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c873_l891_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 892
 fn c874_l892_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c874_l892_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c874_l892_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c874_l892_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 893
 fn c875_l893_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c875_l893_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c875_l893_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c875_l893_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 894
 fn c876_l894_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c876_l894_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c876_l894_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c876_l894_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 895
 fn c877_l895_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c877_l895_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c877_l895_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c877_l895_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 896
 fn c878_l896_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c878_l896_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c878_l896_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c878_l896_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 897
 fn c879_l897_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c879_l897_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c879_l897_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c879_l897_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 898
 fn c880_l898_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c880_l898_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c880_l898_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c880_l898_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -11491,113 +8318,89 @@ fn c912_l930_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 931
 fn c913_l931_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c913_l931_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c913_l931_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c913_l931_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 932
 fn c914_l932_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c914_l932_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c914_l932_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c914_l932_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 933
 fn c915_l933_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c915_l933_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c915_l933_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c915_l933_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 934
 fn c916_l934_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c916_l934_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c916_l934_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c916_l934_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 935
 fn c917_l935_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c917_l935_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c917_l935_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c917_l935_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 936
 fn c918_l936_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c918_l936_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c918_l936_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c918_l936_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 937
 fn c919_l937_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c919_l937_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c919_l937_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c919_l937_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 938
 fn c920_l938_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c920_l938_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c920_l938_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c920_l938_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -11764,10 +8567,7 @@ fn c940_l958_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64)))));
     result.map(|_| ())
 }
@@ -11775,10 +8575,7 @@ fn c941_l959_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64)))));
     result.map(|_| ())
 }
@@ -11786,10 +8583,7 @@ fn c942_l960_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64)))));
     result.map(|_| ())
 }
@@ -11797,10 +8591,7 @@ fn c943_l961_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64)))));
     result.map(|_| ())
 }
@@ -11840,10 +8631,7 @@ fn c948_l966_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -11859,10 +8647,7 @@ fn c950_l968_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11877,185 +8662,89 @@ fn c952_l970_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c953_l971_assert_return_canonical_nan");
+    println!("Executing function {}", "c953_l971_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c953_l971_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c954_l972_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c954_l972_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c954_l972_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c955_l973_assert_return_canonical_nan");
+    println!("Executing function {}", "c955_l973_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c955_l973_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c956_l974_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c956_l974_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c956_l974_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c957_l975_assert_return_canonical_nan");
+    println!("Executing function {}", "c957_l975_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c957_l975_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c958_l976_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c958_l976_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c958_l976_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c959_l977_assert_return_canonical_nan");
+    println!("Executing function {}", "c959_l977_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c959_l977_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c960_l978_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c960_l978_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c960_l978_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -12222,10 +8911,7 @@ fn c980_l998_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -12233,10 +8919,7 @@ fn c981_l999_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -12244,10 +8927,7 @@ fn c982_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -12255,10 +8935,7 @@ fn c983_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -12298,10 +8975,7 @@ fn c988_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -12317,10 +8991,7 @@ fn c990_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -12335,195 +9006,96 @@ fn c992_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c993_l1011_assert_return_canonical_nan");
+    println!("Executing function {}", "c993_l1011_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c993_l1011_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c994_l1012_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c994_l1012_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c994_l1012_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c995_l1013_assert_return_canonical_nan");
+    println!("Executing function {}", "c995_l1013_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c995_l1013_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c996_l1014_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c996_l1014_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c996_l1014_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c997_l1015_assert_return_canonical_nan");
+    println!("Executing function {}", "c997_l1015_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c997_l1015_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c998_l1016_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c998_l1016_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c998_l1016_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c999_l1017_assert_return_canonical_nan");
+    println!("Executing function {}", "c999_l1017_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c999_l1017_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1000_l1018_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1000_l1018_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1000_l1018_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -12531,10 +9103,7 @@ fn c1001_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -12542,10 +9111,7 @@ fn c1002_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -12553,10 +9119,7 @@ fn c1003_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -12628,10 +9191,7 @@ fn c1012_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64)))));
     result.map(|_| ())
 }
@@ -12639,10 +9199,7 @@ fn c1013_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64)))));
     result.map(|_| ())
 }
@@ -12650,10 +9207,7 @@ fn c1014_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64)))));
     result.map(|_| ())
 }
@@ -12661,10 +9215,7 @@ fn c1015_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64)))));
     result.map(|_| ())
 }
@@ -12672,10 +9223,7 @@ fn c1016_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -12683,10 +9231,7 @@ fn c1017_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -12694,10 +9239,7 @@ fn c1018_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -12705,10 +9247,7 @@ fn c1019_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -12716,13 +9255,7 @@ fn c1020_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((39.47841760435743f64)))));
     result.map(|_| ())
 }
@@ -12730,13 +9263,7 @@ fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-39.47841760435743f64)))));
     result.map(|_| ())
 }
@@ -12744,13 +9271,7 @@ fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-39.47841760435743f64)))));
     result.map(|_| ())
 }
@@ -12758,13 +9279,7 @@ fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((39.47841760435743f64)))));
     result.map(|_| ())
 }
@@ -12804,13 +9319,7 @@ fn c1028_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -12818,13 +9327,7 @@ fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -12832,13 +9335,7 @@ fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -12846,198 +9343,96 @@ fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1033_l1051_assert_return_canonical_nan");
+    println!("Executing function {}", "c1033_l1051_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1033_l1051_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1034_l1052_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1034_l1052_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1034_l1052_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1035_l1053_assert_return_canonical_nan");
+    println!("Executing function {}", "c1035_l1053_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1035_l1053_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1036_l1054_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1036_l1054_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1036_l1054_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1037_l1055_assert_return_canonical_nan");
+    println!("Executing function {}", "c1037_l1055_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1037_l1055_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1038_l1056_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1038_l1056_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1038_l1056_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1039_l1057_assert_return_canonical_nan");
+    println!("Executing function {}", "c1039_l1057_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1039_l1057_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1040_l1058_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1040_l1058_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1040_l1058_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -13077,10 +9472,7 @@ fn c1044_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.0000000000000008881784197001251f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64)))));
     result.map(|_| ())
 }
 
@@ -13088,10 +9480,7 @@ fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000000008881784197001251f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64)))));
     result.map(|_| ())
 }
 
@@ -13099,10 +9488,7 @@ fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000000008881784197001251f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64)))));
     result.map(|_| ())
 }
 
@@ -13110,10 +9496,7 @@ fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.0000000000000008881784197001251f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64)))));
     result.map(|_| ())
 }
 
@@ -13311,187 +9694,133 @@ fn c1072_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 1091
 fn c1073_l1091_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1073_l1091_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1073_l1091_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1073_l1091_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1092
 fn c1074_l1092_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1074_l1092_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1074_l1092_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1074_l1092_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1093
 fn c1075_l1093_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1075_l1093_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1075_l1093_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1075_l1093_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1094
 fn c1076_l1094_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1076_l1094_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1076_l1094_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1076_l1094_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1095
 fn c1077_l1095_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1077_l1095_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1077_l1095_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1077_l1095_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1096
 fn c1078_l1096_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1078_l1096_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1078_l1096_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1078_l1096_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1097
 fn c1079_l1097_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1079_l1097_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1079_l1097_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1079_l1097_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1098
 fn c1080_l1098_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1080_l1098_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1080_l1098_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1080_l1098_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((-0.0f64))],
-        )
-        .unwrap()
-        .expect("Missing result in c1081_l1099_assert_return_canonical_nan");
+    println!("Executing function {}", "c1081_l1099_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1081_l1099_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((0.0f64))],
-        )
-        .unwrap()
-        .expect("Missing result in c1082_l1100_assert_return_canonical_nan");
+    println!("Executing function {}", "c1082_l1100_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1082_l1100_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((-0.0f64))])
-        .unwrap()
-        .expect("Missing result in c1083_l1101_assert_return_canonical_nan");
+    println!("Executing function {}", "c1083_l1101_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1083_l1101_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((0.0f64))])
-        .unwrap()
-        .expect("Missing result in c1084_l1102_assert_return_canonical_nan");
+    println!("Executing function {}", "c1084_l1102_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1084_l1102_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -13562,10 +9891,7 @@ fn c1092_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -13573,10 +9899,7 @@ fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.5f64))],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -13600,10 +9923,7 @@ fn c1096_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -13611,10 +9931,7 @@ fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((1.0f64))],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -13638,13 +9955,7 @@ fn c1100_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -13652,13 +9963,7 @@ fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -13666,13 +9971,7 @@ fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -13680,13 +9979,7 @@ fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -13726,10 +10019,7 @@ fn c1108_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -13737,10 +10027,7 @@ fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -13748,10 +10035,7 @@ fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -13759,1887 +10043,1020 @@ fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1113_l1131_assert_return_canonical_nan");
+    println!("Executing function {}", "c1113_l1131_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1113_l1131_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1114_l1132_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1114_l1132_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1114_l1132_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1115_l1133_assert_return_canonical_nan");
+    println!("Executing function {}", "c1115_l1133_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1115_l1133_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1116_l1134_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1116_l1134_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1116_l1134_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1117_l1135_assert_return_canonical_nan");
+    println!("Executing function {}", "c1117_l1135_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1117_l1135_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1118_l1136_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1118_l1136_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1118_l1136_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1119_l1137_assert_return_canonical_nan");
+    println!("Executing function {}", "c1119_l1137_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1119_l1137_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1120_l1138_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1120_l1138_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1120_l1138_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1121_l1139_assert_return_canonical_nan");
+    println!("Executing function {}", "c1121_l1139_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1121_l1139_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1122_l1140_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1122_l1140_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1122_l1140_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1123_l1141_assert_return_canonical_nan");
+    println!("Executing function {}", "c1123_l1141_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1123_l1141_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1124_l1142_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1124_l1142_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1124_l1142_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1125_l1143_assert_return_canonical_nan");
+    println!("Executing function {}", "c1125_l1143_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1125_l1143_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1126_l1144_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1126_l1144_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1126_l1144_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1127_l1145_assert_return_canonical_nan");
+    println!("Executing function {}", "c1127_l1145_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1127_l1145_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1128_l1146_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1128_l1146_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1128_l1146_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1147
 fn c1129_l1147_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1129_l1147_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1129_l1147_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1129_l1147_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1148
 fn c1130_l1148_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1130_l1148_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1130_l1148_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1130_l1148_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1149
 fn c1131_l1149_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1131_l1149_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1131_l1149_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1131_l1149_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1150
 fn c1132_l1150_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1132_l1150_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1132_l1150_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1132_l1150_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1151
 fn c1133_l1151_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1133_l1151_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1133_l1151_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1133_l1151_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1152
 fn c1134_l1152_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1134_l1152_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1134_l1152_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1134_l1152_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1153
 fn c1135_l1153_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1135_l1153_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1135_l1153_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1135_l1153_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1154
 fn c1136_l1154_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1136_l1154_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1136_l1154_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1136_l1154_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1155
 fn c1137_l1155_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1137_l1155_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1137_l1155_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1137_l1155_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1156
 fn c1138_l1156_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1138_l1156_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1138_l1156_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1138_l1156_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1157
 fn c1139_l1157_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1139_l1157_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1139_l1157_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1139_l1157_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1158
 fn c1140_l1158_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1140_l1158_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1140_l1158_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1140_l1158_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1159
 fn c1141_l1159_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1141_l1159_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1141_l1159_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1141_l1159_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1160
 fn c1142_l1160_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1142_l1160_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1142_l1160_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1142_l1160_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1161
 fn c1143_l1161_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1143_l1161_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1143_l1161_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1143_l1161_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1162
 fn c1144_l1162_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1144_l1162_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1144_l1162_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1144_l1162_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1145_l1163_assert_return_canonical_nan");
+    println!("Executing function {}", "c1145_l1163_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1145_l1163_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1146_l1164_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1146_l1164_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1146_l1164_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1147_l1165_assert_return_canonical_nan");
+    println!("Executing function {}", "c1147_l1165_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1147_l1165_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1148_l1166_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1148_l1166_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1148_l1166_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1149_l1167_assert_return_canonical_nan");
+    println!("Executing function {}", "c1149_l1167_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1149_l1167_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1150_l1168_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1150_l1168_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1150_l1168_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1151_l1169_assert_return_canonical_nan");
+    println!("Executing function {}", "c1151_l1169_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1151_l1169_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1152_l1170_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1152_l1170_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1152_l1170_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1153_l1171_assert_return_canonical_nan");
+    println!("Executing function {}", "c1153_l1171_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1153_l1171_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1154_l1172_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1154_l1172_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1154_l1172_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1155_l1173_assert_return_canonical_nan");
+    println!("Executing function {}", "c1155_l1173_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1155_l1173_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1156_l1174_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1156_l1174_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1156_l1174_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1157_l1175_assert_return_canonical_nan");
+    println!("Executing function {}", "c1157_l1175_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1157_l1175_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1158_l1176_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1158_l1176_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1158_l1176_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1159_l1177_assert_return_canonical_nan");
+    println!("Executing function {}", "c1159_l1177_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1159_l1177_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1160_l1178_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1160_l1178_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1160_l1178_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1161_l1179_assert_return_canonical_nan");
+    println!("Executing function {}", "c1161_l1179_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1161_l1179_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1162_l1180_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1162_l1180_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1162_l1180_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1163_l1181_assert_return_canonical_nan");
+    println!("Executing function {}", "c1163_l1181_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1163_l1181_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1164_l1182_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1164_l1182_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1164_l1182_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1165_l1183_assert_return_canonical_nan");
+    println!("Executing function {}", "c1165_l1183_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1165_l1183_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1166_l1184_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1166_l1184_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1166_l1184_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1167_l1185_assert_return_canonical_nan");
+    println!("Executing function {}", "c1167_l1185_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1167_l1185_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1168_l1186_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1168_l1186_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1168_l1186_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1187
 fn c1169_l1187_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1169_l1187_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1169_l1187_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1169_l1187_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1188
 fn c1170_l1188_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1170_l1188_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1170_l1188_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1170_l1188_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1189
 fn c1171_l1189_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1171_l1189_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1171_l1189_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1171_l1189_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1190
 fn c1172_l1190_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1172_l1190_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1172_l1190_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1172_l1190_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1191
 fn c1173_l1191_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1173_l1191_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1173_l1191_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1173_l1191_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1192
 fn c1174_l1192_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1174_l1192_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1174_l1192_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1174_l1192_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1193
 fn c1175_l1193_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1175_l1193_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1175_l1193_assert_return_canonical_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1175_l1193_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1194
 fn c1176_l1194_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1176_l1194_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1176_l1194_assert_return_arithmetic_nan");
     let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1176_l1194_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1177_l1195_assert_return_canonical_nan");
+    println!("Executing function {}", "c1177_l1195_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1177_l1195_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1178_l1196_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1178_l1196_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1178_l1196_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1179_l1197_assert_return_canonical_nan");
+    println!("Executing function {}", "c1179_l1197_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1179_l1197_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1180_l1198_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1180_l1198_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1180_l1198_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1181_l1199_assert_return_canonical_nan");
+    println!("Executing function {}", "c1181_l1199_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1181_l1199_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1182_l1200_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1182_l1200_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1182_l1200_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1183_l1201_assert_return_canonical_nan");
+    println!("Executing function {}", "c1183_l1201_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1183_l1201_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1184_l1202_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1184_l1202_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1184_l1202_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1185_l1203_assert_return_canonical_nan");
+    println!("Executing function {}", "c1185_l1203_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1185_l1203_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1186_l1204_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1186_l1204_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1186_l1204_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1187_l1205_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1187_l1205_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1187_l1205_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1188_l1206_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1188_l1206_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1188_l1206_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1189_l1207_assert_return_canonical_nan");
+    println!("Executing function {}", "c1189_l1207_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1189_l1207_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1190_l1208_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1190_l1208_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1190_l1208_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1191_l1209_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1191_l1209_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1191_l1209_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1192_l1210_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1192_l1210_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1192_l1210_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1193_l1211_assert_return_canonical_nan");
+    println!("Executing function {}", "c1193_l1211_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1193_l1211_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1194_l1212_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1194_l1212_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1194_l1212_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1195_l1213_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1195_l1213_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1195_l1213_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1196_l1214_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1196_l1214_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1196_l1214_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1197_l1215_assert_return_canonical_nan");
+    println!("Executing function {}", "c1197_l1215_assert_return_canonical_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1197_l1215_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1198_l1216_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1198_l1216_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1198_l1216_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1199_l1217_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1199_l1217_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1199_l1217_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1200_l1218_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1200_l1218_assert_return_arithmetic_nan");
+    let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1200_l1218_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((-0.0f64))])
-        .unwrap()
-        .expect("Missing result in c1201_l1219_assert_return_canonical_nan");
+    println!("Executing function {}", "c1201_l1219_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1201_l1219_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((0.0f64))])
-        .unwrap()
-        .expect("Missing result in c1202_l1220_assert_return_canonical_nan");
+    println!("Executing function {}", "c1202_l1220_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1202_l1220_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((-0.0f64))])
-        .unwrap()
-        .expect("Missing result in c1203_l1221_assert_return_canonical_nan");
+    println!("Executing function {}", "c1203_l1221_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1203_l1221_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((0.0f64))])
-        .unwrap()
-        .expect("Missing result in c1204_l1222_assert_return_canonical_nan");
+    println!("Executing function {}", "c1204_l1222_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1204_l1222_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -15774,10 +11191,7 @@ fn c1220_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -15785,10 +11199,7 @@ fn c1221_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -15796,10 +11207,7 @@ fn c1222_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -15807,10 +11215,7 @@ fn c1223_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -15850,10 +11255,7 @@ fn c1228_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -15869,10 +11271,7 @@ fn c1230_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -15887,185 +11286,89 @@ fn c1232_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1233_l1251_assert_return_canonical_nan");
+    println!("Executing function {}", "c1233_l1251_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1233_l1251_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1234_l1252_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1234_l1252_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1234_l1252_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1235_l1253_assert_return_canonical_nan");
+    println!("Executing function {}", "c1235_l1253_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1235_l1253_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1236_l1254_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1236_l1254_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1236_l1254_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1237_l1255_assert_return_canonical_nan");
+    println!("Executing function {}", "c1237_l1255_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1237_l1255_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1238_l1256_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1238_l1256_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1238_l1256_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1239_l1257_assert_return_canonical_nan");
+    println!("Executing function {}", "c1239_l1257_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1239_l1257_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1240_l1258_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1240_l1258_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1240_l1258_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -16137,10 +11440,7 @@ fn c1248_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.0000000000000002220446049250313f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))));
     result.map(|_| ())
 }
 
@@ -16148,10 +11448,7 @@ fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000000002220446049250313f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64)))));
     result.map(|_| ())
 }
 
@@ -16159,10 +11456,7 @@ fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000000002220446049250313f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64)))));
     result.map(|_| ())
 }
 
@@ -16170,10 +11464,7 @@ fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.0000000000000002220446049250313f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))));
     result.map(|_| ())
 }
 
@@ -16339,113 +11630,89 @@ fn c1272_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 1291
 fn c1273_l1291_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1273_l1291_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1273_l1291_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1273_l1291_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1292
 fn c1274_l1292_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1274_l1292_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1274_l1292_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1274_l1292_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1293
 fn c1275_l1293_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1275_l1293_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1275_l1293_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1275_l1293_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1294
 fn c1276_l1294_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1276_l1294_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1276_l1294_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1276_l1294_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1295
 fn c1277_l1295_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1277_l1295_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1277_l1295_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1277_l1295_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1296
 fn c1278_l1296_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1278_l1296_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1278_l1296_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1278_l1296_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1297
 fn c1279_l1297_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1279_l1297_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1279_l1297_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1279_l1297_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1298
 fn c1280_l1298_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1280_l1298_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1280_l1298_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1280_l1298_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -16707,113 +11974,89 @@ fn c1312_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 1331
 fn c1313_l1331_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1313_l1331_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1313_l1331_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1313_l1331_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1332
 fn c1314_l1332_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1314_l1332_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1314_l1332_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1314_l1332_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1333
 fn c1315_l1333_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1315_l1333_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1315_l1333_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1315_l1333_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1334
 fn c1316_l1334_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1316_l1334_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1316_l1334_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1316_l1334_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1335
 fn c1317_l1335_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1317_l1335_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1317_l1335_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1317_l1335_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1336
 fn c1318_l1336_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1318_l1336_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1318_l1336_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1318_l1336_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1337
 fn c1319_l1337_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1319_l1337_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1319_l1337_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1319_l1337_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1338
 fn c1320_l1338_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1320_l1338_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1320_l1338_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1320_l1338_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -16980,10 +12223,7 @@ fn c1340_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.07957747154594767f64)))));
     result.map(|_| ())
 }
@@ -16991,10 +12231,7 @@ fn c1341_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.07957747154594767f64)))));
     result.map(|_| ())
 }
@@ -17002,10 +12239,7 @@ fn c1342_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.07957747154594767f64)))));
     result.map(|_| ())
 }
@@ -17013,10 +12247,7 @@ fn c1343_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.07957747154594767f64)))));
     result.map(|_| ())
 }
@@ -17056,10 +12287,7 @@ fn c1348_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -17075,10 +12303,7 @@ fn c1350_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -17093,185 +12318,89 @@ fn c1352_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1353_l1371_assert_return_canonical_nan");
+    println!("Executing function {}", "c1353_l1371_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1353_l1371_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1354_l1372_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1354_l1372_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1354_l1372_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1355_l1373_assert_return_canonical_nan");
+    println!("Executing function {}", "c1355_l1373_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1355_l1373_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1356_l1374_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1356_l1374_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1356_l1374_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1357_l1375_assert_return_canonical_nan");
+    println!("Executing function {}", "c1357_l1375_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1357_l1375_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1358_l1376_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1358_l1376_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1358_l1376_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1359_l1377_assert_return_canonical_nan");
+    println!("Executing function {}", "c1359_l1377_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1359_l1377_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1360_l1378_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1360_l1378_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1360_l1378_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -17438,10 +12567,7 @@ fn c1380_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.15915494309189535f64)))));
     result.map(|_| ())
 }
@@ -17449,10 +12575,7 @@ fn c1381_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.15915494309189535f64)))));
     result.map(|_| ())
 }
@@ -17460,10 +12583,7 @@ fn c1382_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.15915494309189535f64)))));
     result.map(|_| ())
 }
@@ -17471,10 +12591,7 @@ fn c1383_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.15915494309189535f64)))));
     result.map(|_| ())
 }
@@ -17514,10 +12631,7 @@ fn c1388_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -17533,10 +12647,7 @@ fn c1390_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -17551,195 +12662,96 @@ fn c1392_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1393_l1411_assert_return_canonical_nan");
+    println!("Executing function {}", "c1393_l1411_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1393_l1411_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1394_l1412_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1394_l1412_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1394_l1412_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1395_l1413_assert_return_canonical_nan");
+    println!("Executing function {}", "c1395_l1413_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1395_l1413_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1396_l1414_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1396_l1414_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1396_l1414_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1397_l1415_assert_return_canonical_nan");
+    println!("Executing function {}", "c1397_l1415_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1397_l1415_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1398_l1416_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1398_l1416_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1398_l1416_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1399_l1417_assert_return_canonical_nan");
+    println!("Executing function {}", "c1399_l1417_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1399_l1417_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1400_l1418_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1400_l1418_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1400_l1418_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -17747,10 +12759,7 @@ fn c1401_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17758,10 +12767,7 @@ fn c1402_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -17769,10 +12775,7 @@ fn c1403_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -17844,10 +12847,7 @@ fn c1412_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64)))));
     result.map(|_| ())
 }
@@ -17855,10 +12855,7 @@ fn c1413_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64)))));
     result.map(|_| ())
 }
@@ -17866,10 +12863,7 @@ fn c1414_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64)))));
     result.map(|_| ())
 }
@@ -17877,10 +12871,7 @@ fn c1415_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64)))));
     result.map(|_| ())
 }
@@ -17888,10 +12879,7 @@ fn c1416_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -17899,10 +12887,7 @@ fn c1417_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -17910,10 +12895,7 @@ fn c1418_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -17921,10 +12903,7 @@ fn c1419_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -17932,13 +12911,7 @@ fn c1420_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -17946,13 +12919,7 @@ fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -17960,13 +12927,7 @@ fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -17974,13 +12935,7 @@ fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -18020,13 +12975,7 @@ fn c1428_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -18034,13 +12983,7 @@ fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -18048,13 +12991,7 @@ fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -18062,198 +12999,96 @@ fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1433_l1451_assert_return_canonical_nan");
+    println!("Executing function {}", "c1433_l1451_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1433_l1451_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1434_l1452_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1434_l1452_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1434_l1452_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1435_l1453_assert_return_canonical_nan");
+    println!("Executing function {}", "c1435_l1453_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1435_l1453_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1436_l1454_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1436_l1454_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1436_l1454_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1437_l1455_assert_return_canonical_nan");
+    println!("Executing function {}", "c1437_l1455_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1437_l1455_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1438_l1456_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1438_l1456_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1438_l1456_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1439_l1457_assert_return_canonical_nan");
+    println!("Executing function {}", "c1439_l1457_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1439_l1457_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1440_l1458_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1440_l1458_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1440_l1458_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -18515,123 +13350,96 @@ fn c1472_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 1491
 fn c1473_l1491_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1473_l1491_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1473_l1491_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1473_l1491_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1492
 fn c1474_l1492_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1474_l1492_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1474_l1492_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1474_l1492_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1493
 fn c1475_l1493_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1475_l1493_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1475_l1493_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1475_l1493_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1494
 fn c1476_l1494_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1476_l1494_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1476_l1494_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1476_l1494_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1495
 fn c1477_l1495_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1477_l1495_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1477_l1495_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1477_l1495_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1496
 fn c1478_l1496_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1478_l1496_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1478_l1496_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1478_l1496_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1497
 fn c1479_l1497_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1479_l1497_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1479_l1497_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1479_l1497_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1498
 fn c1480_l1498_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1480_l1498_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1480_l1498_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1480_l1498_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -18639,10 +13447,7 @@ fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18730,10 +13535,7 @@ fn c1492_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -18741,10 +13543,7 @@ fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.5f64))],
-    );
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18768,10 +13567,7 @@ fn c1496_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -18779,10 +13575,7 @@ fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((1.0f64))],
-    );
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18806,13 +13599,7 @@ fn c1500_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -18820,13 +13607,7 @@ fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18834,13 +13615,7 @@ fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -18848,13 +13623,7 @@ fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -18893,1889 +13662,1013 @@ fn c1508_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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), Value::F64(f64::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c1509_l1527_assert_return_canonical_nan");
+    println!("Executing function {}", "c1509_l1527_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1509_l1527_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64(f64::INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c1510_l1528_assert_return_canonical_nan");
+    println!("Executing function {}", "c1510_l1528_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1510_l1528_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64(f64::NEG_INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c1511_l1529_assert_return_canonical_nan");
+    println!("Executing function {}", "c1511_l1529_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1511_l1529_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64(f64::INFINITY)],
-        )
-        .unwrap()
-        .expect("Missing result in c1512_l1530_assert_return_canonical_nan");
+    println!("Executing function {}", "c1512_l1530_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1512_l1530_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1513_l1531_assert_return_canonical_nan");
+    println!("Executing function {}", "c1513_l1531_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1513_l1531_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1514_l1532_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1514_l1532_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1514_l1532_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1515_l1533_assert_return_canonical_nan");
+    println!("Executing function {}", "c1515_l1533_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1515_l1533_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1516_l1534_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1516_l1534_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1516_l1534_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1517_l1535_assert_return_canonical_nan");
+    println!("Executing function {}", "c1517_l1535_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1517_l1535_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1518_l1536_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1518_l1536_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1518_l1536_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1519_l1537_assert_return_canonical_nan");
+    println!("Executing function {}", "c1519_l1537_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1519_l1537_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1520_l1538_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1520_l1538_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1520_l1538_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1521_l1539_assert_return_canonical_nan");
+    println!("Executing function {}", "c1521_l1539_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1521_l1539_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1522_l1540_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1522_l1540_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1522_l1540_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1523_l1541_assert_return_canonical_nan");
+    println!("Executing function {}", "c1523_l1541_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1523_l1541_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1524_l1542_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1524_l1542_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1524_l1542_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1525_l1543_assert_return_canonical_nan");
+    println!("Executing function {}", "c1525_l1543_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1525_l1543_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1526_l1544_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1526_l1544_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1526_l1544_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1527_l1545_assert_return_canonical_nan");
+    println!("Executing function {}", "c1527_l1545_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1527_l1545_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1528_l1546_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1528_l1546_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1528_l1546_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1547
 fn c1529_l1547_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1529_l1547_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1529_l1547_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1529_l1547_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1548
 fn c1530_l1548_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1530_l1548_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1530_l1548_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1530_l1548_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1549
 fn c1531_l1549_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1531_l1549_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1531_l1549_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1531_l1549_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1550
 fn c1532_l1550_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1532_l1550_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1532_l1550_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1532_l1550_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1551
 fn c1533_l1551_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1533_l1551_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1533_l1551_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1533_l1551_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1552
 fn c1534_l1552_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1534_l1552_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1534_l1552_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1534_l1552_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1553
 fn c1535_l1553_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1535_l1553_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1535_l1553_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1535_l1553_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1554
 fn c1536_l1554_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1536_l1554_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1536_l1554_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1536_l1554_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1555
 fn c1537_l1555_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1537_l1555_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1537_l1555_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1537_l1555_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1556
 fn c1538_l1556_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1538_l1556_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1538_l1556_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1538_l1556_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1557
 fn c1539_l1557_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1539_l1557_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1539_l1557_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1539_l1557_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1558
 fn c1540_l1558_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1540_l1558_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1540_l1558_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1540_l1558_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1559
 fn c1541_l1559_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1541_l1559_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1541_l1559_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1541_l1559_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1560
 fn c1542_l1560_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1542_l1560_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1542_l1560_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1542_l1560_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1561
 fn c1543_l1561_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1543_l1561_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1543_l1561_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1543_l1561_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1562
 fn c1544_l1562_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1544_l1562_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1544_l1562_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1544_l1562_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1545_l1563_assert_return_canonical_nan");
+    println!("Executing function {}", "c1545_l1563_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1545_l1563_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1546_l1564_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1546_l1564_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1546_l1564_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1547_l1565_assert_return_canonical_nan");
+    println!("Executing function {}", "c1547_l1565_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1547_l1565_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1548_l1566_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1548_l1566_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1548_l1566_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1549_l1567_assert_return_canonical_nan");
+    println!("Executing function {}", "c1549_l1567_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1549_l1567_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1550_l1568_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1550_l1568_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1550_l1568_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1551_l1569_assert_return_canonical_nan");
+    println!("Executing function {}", "c1551_l1569_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1551_l1569_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1552_l1570_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1552_l1570_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1552_l1570_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1553_l1571_assert_return_canonical_nan");
+    println!("Executing function {}", "c1553_l1571_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1553_l1571_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1554_l1572_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1554_l1572_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1554_l1572_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1555_l1573_assert_return_canonical_nan");
+    println!("Executing function {}", "c1555_l1573_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1555_l1573_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1556_l1574_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1556_l1574_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1556_l1574_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1557_l1575_assert_return_canonical_nan");
+    println!("Executing function {}", "c1557_l1575_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1557_l1575_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1558_l1576_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1558_l1576_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1558_l1576_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1559_l1577_assert_return_canonical_nan");
+    println!("Executing function {}", "c1559_l1577_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1559_l1577_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1560_l1578_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1560_l1578_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1560_l1578_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1561_l1579_assert_return_canonical_nan");
+    println!("Executing function {}", "c1561_l1579_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1561_l1579_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1562_l1580_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1562_l1580_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1562_l1580_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1563_l1581_assert_return_canonical_nan");
+    println!("Executing function {}", "c1563_l1581_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1563_l1581_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1564_l1582_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1564_l1582_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1564_l1582_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1565_l1583_assert_return_canonical_nan");
+    println!("Executing function {}", "c1565_l1583_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1565_l1583_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1566_l1584_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1566_l1584_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1566_l1584_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1567_l1585_assert_return_canonical_nan");
+    println!("Executing function {}", "c1567_l1585_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1567_l1585_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1568_l1586_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1568_l1586_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1568_l1586_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1587
 fn c1569_l1587_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1569_l1587_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1569_l1587_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1569_l1587_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1588
 fn c1570_l1588_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1570_l1588_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1570_l1588_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1570_l1588_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1589
 fn c1571_l1589_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1571_l1589_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1571_l1589_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1571_l1589_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1590
 fn c1572_l1590_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1572_l1590_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1572_l1590_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1572_l1590_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1591
 fn c1573_l1591_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1573_l1591_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1573_l1591_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1573_l1591_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1592
 fn c1574_l1592_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1574_l1592_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1574_l1592_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1574_l1592_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1593
 fn c1575_l1593_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1575_l1593_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1575_l1593_assert_return_canonical_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1575_l1593_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1594
 fn c1576_l1594_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1576_l1594_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1576_l1594_assert_return_arithmetic_nan");
     let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1576_l1594_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1577_l1595_assert_return_canonical_nan");
+    println!("Executing function {}", "c1577_l1595_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1577_l1595_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1578_l1596_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1578_l1596_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1578_l1596_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1579_l1597_assert_return_canonical_nan");
+    println!("Executing function {}", "c1579_l1597_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1579_l1597_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1580_l1598_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1580_l1598_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1580_l1598_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1581_l1599_assert_return_canonical_nan");
+    println!("Executing function {}", "c1581_l1599_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1581_l1599_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1582_l1600_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1582_l1600_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1582_l1600_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1583_l1601_assert_return_canonical_nan");
+    println!("Executing function {}", "c1583_l1601_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1583_l1601_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1584_l1602_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1584_l1602_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1584_l1602_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1585_l1603_assert_return_canonical_nan");
+    println!("Executing function {}", "c1585_l1603_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1585_l1603_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1586_l1604_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1586_l1604_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1586_l1604_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1587_l1605_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1587_l1605_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1587_l1605_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1588_l1606_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1588_l1606_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1588_l1606_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1589_l1607_assert_return_canonical_nan");
+    println!("Executing function {}", "c1589_l1607_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1589_l1607_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1590_l1608_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1590_l1608_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1590_l1608_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1591_l1609_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1591_l1609_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1591_l1609_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1592_l1610_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1592_l1610_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1592_l1610_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1593_l1611_assert_return_canonical_nan");
+    println!("Executing function {}", "c1593_l1611_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1593_l1611_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1594_l1612_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1594_l1612_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1594_l1612_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1595_l1613_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1595_l1613_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1595_l1613_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1596_l1614_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1596_l1614_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1596_l1614_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1597_l1615_assert_return_canonical_nan");
+    println!("Executing function {}", "c1597_l1615_assert_return_canonical_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1597_l1615_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1598_l1616_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1598_l1616_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1598_l1616_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1599_l1617_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1599_l1617_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1599_l1617_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1600_l1618_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1600_l1618_assert_return_arithmetic_nan");
+    let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1600_l1618_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -20942,10 +14835,7 @@ fn c1620_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -20953,10 +14843,7 @@ fn c1621_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -20964,10 +14851,7 @@ fn c1622_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -20975,10 +14859,7 @@ fn c1623_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -21018,10 +14899,7 @@ fn c1628_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -21037,10 +14915,7 @@ fn c1630_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -21055,185 +14930,89 @@ fn c1632_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1633_l1651_assert_return_canonical_nan");
+    println!("Executing function {}", "c1633_l1651_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1633_l1651_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1634_l1652_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1634_l1652_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1634_l1652_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1635_l1653_assert_return_canonical_nan");
+    println!("Executing function {}", "c1635_l1653_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1635_l1653_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1636_l1654_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1636_l1654_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1636_l1654_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1637_l1655_assert_return_canonical_nan");
+    println!("Executing function {}", "c1637_l1655_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1637_l1655_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1638_l1656_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1638_l1656_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1638_l1656_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1639_l1657_assert_return_canonical_nan");
+    println!("Executing function {}", "c1639_l1657_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1639_l1657_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1640_l1658_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1640_l1658_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1640_l1658_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -21495,113 +15274,89 @@ fn c1672_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 1691
 fn c1673_l1691_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1673_l1691_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1673_l1691_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1673_l1691_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1692
 fn c1674_l1692_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1674_l1692_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1674_l1692_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1674_l1692_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1693
 fn c1675_l1693_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1675_l1693_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1675_l1693_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1675_l1693_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1694
 fn c1676_l1694_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1676_l1694_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1676_l1694_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1676_l1694_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1695
 fn c1677_l1695_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1677_l1695_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1677_l1695_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1677_l1695_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1696
 fn c1678_l1696_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1678_l1696_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1678_l1696_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1678_l1696_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1697
 fn c1679_l1697_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1679_l1697_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1679_l1697_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1679_l1697_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1698
 fn c1680_l1698_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1680_l1698_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1680_l1698_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1680_l1698_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -21863,113 +15618,89 @@ fn c1712_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 1731
 fn c1713_l1731_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1713_l1731_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1713_l1731_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1713_l1731_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1732
 fn c1714_l1732_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1714_l1732_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1714_l1732_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1714_l1732_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1733
 fn c1715_l1733_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1715_l1733_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1715_l1733_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1715_l1733_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1734
 fn c1716_l1734_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1716_l1734_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1716_l1734_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1716_l1734_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1735
 fn c1717_l1735_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1717_l1735_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1717_l1735_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1717_l1735_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1736
 fn c1718_l1736_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1718_l1736_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1718_l1736_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1718_l1736_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1737
 fn c1719_l1737_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1719_l1737_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1719_l1737_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1719_l1737_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1738
 fn c1720_l1738_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1720_l1738_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1720_l1738_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1720_l1738_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -22136,10 +15867,7 @@ fn c1740_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -22147,10 +15875,7 @@ fn c1741_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -22158,10 +15883,7 @@ fn c1742_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -22169,10 +15891,7 @@ fn c1743_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -22212,10 +15931,7 @@ fn c1748_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -22231,10 +15947,7 @@ fn c1750_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -22249,185 +15962,89 @@ fn c1752_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1753_l1771_assert_return_canonical_nan");
+    println!("Executing function {}", "c1753_l1771_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1753_l1771_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1754_l1772_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1754_l1772_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1754_l1772_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1755_l1773_assert_return_canonical_nan");
+    println!("Executing function {}", "c1755_l1773_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1755_l1773_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1756_l1774_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1756_l1774_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1756_l1774_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1757_l1775_assert_return_canonical_nan");
+    println!("Executing function {}", "c1757_l1775_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1757_l1775_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1758_l1776_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1758_l1776_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1758_l1776_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1759_l1777_assert_return_canonical_nan");
+    println!("Executing function {}", "c1759_l1777_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1759_l1777_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1760_l1778_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1760_l1778_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1760_l1778_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -22594,10 +16211,7 @@ fn c1780_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -22605,10 +16219,7 @@ fn c1781_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -22616,10 +16227,7 @@ fn c1782_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -22627,10 +16235,7 @@ fn c1783_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -22670,10 +16275,7 @@ fn c1788_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -22689,10 +16291,7 @@ fn c1790_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -22707,195 +16306,96 @@ fn c1792_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1793_l1811_assert_return_canonical_nan");
+    println!("Executing function {}", "c1793_l1811_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1793_l1811_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1794_l1812_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1794_l1812_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1794_l1812_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1795_l1813_assert_return_canonical_nan");
+    println!("Executing function {}", "c1795_l1813_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1795_l1813_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1796_l1814_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1796_l1814_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1796_l1814_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1797_l1815_assert_return_canonical_nan");
+    println!("Executing function {}", "c1797_l1815_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1797_l1815_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1798_l1816_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1798_l1816_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1798_l1816_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1799_l1817_assert_return_canonical_nan");
+    println!("Executing function {}", "c1799_l1817_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1799_l1817_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1800_l1818_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1800_l1818_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1800_l1818_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -22903,10 +16403,7 @@ fn c1801_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -22914,10 +16411,7 @@ fn c1802_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -22925,10 +16419,7 @@ fn c1803_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -23000,10 +16491,7 @@ fn c1812_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23011,10 +16499,7 @@ fn c1813_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23022,10 +16507,7 @@ fn c1814_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -23033,10 +16515,7 @@ fn c1815_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -23044,10 +16523,7 @@ fn c1816_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23055,10 +16531,7 @@ fn c1817_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23066,10 +16539,7 @@ fn c1818_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -23077,10 +16547,7 @@ fn c1819_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -23088,13 +16555,7 @@ fn c1820_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23102,13 +16563,7 @@ fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23116,13 +16571,7 @@ fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23130,13 +16579,7 @@ fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23176,13 +16619,7 @@ fn c1828_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23190,13 +16627,7 @@ fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -23204,13 +16635,7 @@ fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23218,198 +16643,96 @@ fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1833_l1851_assert_return_canonical_nan");
+    println!("Executing function {}", "c1833_l1851_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1833_l1851_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1834_l1852_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1834_l1852_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1834_l1852_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1835_l1853_assert_return_canonical_nan");
+    println!("Executing function {}", "c1835_l1853_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1835_l1853_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1836_l1854_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1836_l1854_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1836_l1854_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1837_l1855_assert_return_canonical_nan");
+    println!("Executing function {}", "c1837_l1855_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1837_l1855_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1838_l1856_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1838_l1856_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1838_l1856_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1839_l1857_assert_return_canonical_nan");
+    println!("Executing function {}", "c1839_l1857_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1839_l1857_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1840_l1858_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1840_l1858_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1840_l1858_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -23671,123 +16994,96 @@ fn c1872_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 1891
 fn c1873_l1891_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1873_l1891_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1873_l1891_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1873_l1891_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1892
 fn c1874_l1892_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1874_l1892_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1874_l1892_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1874_l1892_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1893
 fn c1875_l1893_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1875_l1893_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1875_l1893_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1875_l1893_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1894
 fn c1876_l1894_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1876_l1894_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1876_l1894_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1876_l1894_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1895
 fn c1877_l1895_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1877_l1895_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1877_l1895_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1877_l1895_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1896
 fn c1878_l1896_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1878_l1896_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1878_l1896_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1878_l1896_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1897
 fn c1879_l1897_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1879_l1897_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1879_l1897_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1879_l1897_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1898
 fn c1880_l1898_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1880_l1898_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1880_l1898_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1880_l1898_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23795,10 +17091,7 @@ fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23886,10 +17179,7 @@ fn c1892_l1910_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23897,10 +17187,7 @@ fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.5f64))],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23924,10 +17211,7 @@ fn c1896_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23935,10 +17219,7 @@ fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((1.0f64))],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23962,13 +17243,7 @@ fn c1900_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23976,13 +17251,7 @@ fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -23990,13 +17259,7 @@ fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -24004,13 +17267,7 @@ fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -24050,10 +17307,7 @@ fn c1908_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24061,10 +17315,7 @@ fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24072,10 +17323,7 @@ fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -24083,1819 +17331,976 @@ fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1913_l1931_assert_return_canonical_nan");
+    println!("Executing function {}", "c1913_l1931_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1913_l1931_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1914_l1932_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1914_l1932_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1914_l1932_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1915_l1933_assert_return_canonical_nan");
+    println!("Executing function {}", "c1915_l1933_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1915_l1933_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1916_l1934_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1916_l1934_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1916_l1934_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1917_l1935_assert_return_canonical_nan");
+    println!("Executing function {}", "c1917_l1935_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1917_l1935_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1918_l1936_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1918_l1936_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1918_l1936_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1919_l1937_assert_return_canonical_nan");
+    println!("Executing function {}", "c1919_l1937_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1919_l1937_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1920_l1938_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1920_l1938_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1920_l1938_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1921_l1939_assert_return_canonical_nan");
+    println!("Executing function {}", "c1921_l1939_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1921_l1939_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1922_l1940_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1922_l1940_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1922_l1940_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1923_l1941_assert_return_canonical_nan");
+    println!("Executing function {}", "c1923_l1941_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1923_l1941_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1924_l1942_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1924_l1942_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1924_l1942_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1925_l1943_assert_return_canonical_nan");
+    println!("Executing function {}", "c1925_l1943_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1925_l1943_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1926_l1944_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1926_l1944_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1926_l1944_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1927_l1945_assert_return_canonical_nan");
+    println!("Executing function {}", "c1927_l1945_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1927_l1945_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1928_l1946_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1928_l1946_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1928_l1946_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1947
 fn c1929_l1947_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1929_l1947_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1929_l1947_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1929_l1947_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1948
 fn c1930_l1948_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1930_l1948_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1930_l1948_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1930_l1948_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1949
 fn c1931_l1949_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1931_l1949_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1931_l1949_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1931_l1949_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1950
 fn c1932_l1950_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1932_l1950_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1932_l1950_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1932_l1950_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1951
 fn c1933_l1951_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1933_l1951_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1933_l1951_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1933_l1951_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1952
 fn c1934_l1952_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1934_l1952_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1934_l1952_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1934_l1952_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1953
 fn c1935_l1953_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1935_l1953_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1935_l1953_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1935_l1953_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1954
 fn c1936_l1954_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1936_l1954_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1936_l1954_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1936_l1954_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1955
 fn c1937_l1955_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1937_l1955_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1937_l1955_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1937_l1955_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1956
 fn c1938_l1956_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1938_l1956_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1938_l1956_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1938_l1956_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1957
 fn c1939_l1957_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1939_l1957_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1939_l1957_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1939_l1957_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1958
 fn c1940_l1958_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1940_l1958_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1940_l1958_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1940_l1958_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1959
 fn c1941_l1959_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1941_l1959_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1941_l1959_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1941_l1959_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1960
 fn c1942_l1960_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1942_l1960_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1942_l1960_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1942_l1960_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1961
 fn c1943_l1961_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1943_l1961_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1943_l1961_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1943_l1961_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1962
 fn c1944_l1962_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1944_l1962_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1944_l1962_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1944_l1962_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1945_l1963_assert_return_canonical_nan");
+    println!("Executing function {}", "c1945_l1963_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1945_l1963_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1946_l1964_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1946_l1964_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1946_l1964_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1947_l1965_assert_return_canonical_nan");
+    println!("Executing function {}", "c1947_l1965_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1947_l1965_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1948_l1966_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1948_l1966_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1948_l1966_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1949_l1967_assert_return_canonical_nan");
+    println!("Executing function {}", "c1949_l1967_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1949_l1967_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1950_l1968_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1950_l1968_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1950_l1968_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1951_l1969_assert_return_canonical_nan");
+    println!("Executing function {}", "c1951_l1969_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1951_l1969_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1952_l1970_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1952_l1970_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1952_l1970_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1953_l1971_assert_return_canonical_nan");
+    println!("Executing function {}", "c1953_l1971_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1953_l1971_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1954_l1972_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1954_l1972_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1954_l1972_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1955_l1973_assert_return_canonical_nan");
+    println!("Executing function {}", "c1955_l1973_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1955_l1973_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1956_l1974_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1956_l1974_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1956_l1974_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1957_l1975_assert_return_canonical_nan");
+    println!("Executing function {}", "c1957_l1975_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1957_l1975_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1958_l1976_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1958_l1976_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1958_l1976_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1959_l1977_assert_return_canonical_nan");
+    println!("Executing function {}", "c1959_l1977_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1959_l1977_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1960_l1978_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1960_l1978_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1960_l1978_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1961_l1979_assert_return_canonical_nan");
+    println!("Executing function {}", "c1961_l1979_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1961_l1979_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1962_l1980_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1962_l1980_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1962_l1980_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1963_l1981_assert_return_canonical_nan");
+    println!("Executing function {}", "c1963_l1981_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1963_l1981_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1964_l1982_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1964_l1982_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1964_l1982_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1965_l1983_assert_return_canonical_nan");
+    println!("Executing function {}", "c1965_l1983_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1965_l1983_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1966_l1984_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1966_l1984_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1966_l1984_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1967_l1985_assert_return_canonical_nan");
+    println!("Executing function {}", "c1967_l1985_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1967_l1985_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1968_l1986_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1968_l1986_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1968_l1986_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1987
 fn c1969_l1987_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1969_l1987_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1969_l1987_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1969_l1987_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1988
 fn c1970_l1988_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1970_l1988_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1970_l1988_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1970_l1988_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1989
 fn c1971_l1989_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1971_l1989_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1971_l1989_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1971_l1989_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1990
 fn c1972_l1990_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1972_l1990_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1972_l1990_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1972_l1990_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1991
 fn c1973_l1991_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1973_l1991_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1973_l1991_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1973_l1991_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1992
 fn c1974_l1992_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1974_l1992_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1974_l1992_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1974_l1992_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1993
 fn c1975_l1993_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1975_l1993_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c1975_l1993_assert_return_canonical_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1975_l1993_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 1994
 fn c1976_l1994_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c1976_l1994_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c1976_l1994_assert_return_arithmetic_nan");
     let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1976_l1994_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1977_l1995_assert_return_canonical_nan");
+    println!("Executing function {}", "c1977_l1995_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1977_l1995_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1978_l1996_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1978_l1996_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1978_l1996_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1979_l1997_assert_return_canonical_nan");
+    println!("Executing function {}", "c1979_l1997_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1979_l1997_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1980_l1998_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1980_l1998_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1980_l1998_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1981_l1999_assert_return_canonical_nan");
+    println!("Executing function {}", "c1981_l1999_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1981_l1999_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1982_l2000_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1982_l2000_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1982_l2000_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1983_l2001_assert_return_canonical_nan");
+    println!("Executing function {}", "c1983_l2001_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1983_l2001_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1984_l2002_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1984_l2002_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1984_l2002_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1985_l2003_assert_return_canonical_nan");
+    println!("Executing function {}", "c1985_l2003_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1985_l2003_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1986_l2004_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1986_l2004_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1986_l2004_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1987_l2005_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1987_l2005_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1987_l2005_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1988_l2006_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1988_l2006_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1988_l2006_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1989_l2007_assert_return_canonical_nan");
+    println!("Executing function {}", "c1989_l2007_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1989_l2007_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1990_l2008_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1990_l2008_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1990_l2008_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1991_l2009_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1991_l2009_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1991_l2009_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1992_l2010_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1992_l2010_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1992_l2010_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1993_l2011_assert_return_canonical_nan");
+    println!("Executing function {}", "c1993_l2011_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1993_l2011_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1994_l2012_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1994_l2012_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1994_l2012_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1995_l2013_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1995_l2013_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1995_l2013_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1996_l2014_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1996_l2014_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1996_l2014_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1997_l2015_assert_return_canonical_nan");
+    println!("Executing function {}", "c1997_l2015_assert_return_canonical_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1997_l2015_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1998_l2016_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1998_l2016_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1998_l2016_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c1999_l2017_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c1999_l2017_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1999_l2017_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2000_l2018_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2000_l2018_assert_return_arithmetic_nan");
+    let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2000_l2018_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -26062,10 +18467,7 @@ fn c2020_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -26073,10 +18475,7 @@ fn c2021_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -26084,10 +18483,7 @@ fn c2022_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -26095,10 +18491,7 @@ fn c2023_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -26138,10 +18531,7 @@ fn c2028_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -26157,10 +18547,7 @@ fn c2030_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -26175,185 +18562,89 @@ fn c2032_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2033_l2051_assert_return_canonical_nan");
+    println!("Executing function {}", "c2033_l2051_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2033_l2051_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2034_l2052_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2034_l2052_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2034_l2052_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2035_l2053_assert_return_canonical_nan");
+    println!("Executing function {}", "c2035_l2053_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2035_l2053_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2036_l2054_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2036_l2054_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2036_l2054_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2037_l2055_assert_return_canonical_nan");
+    println!("Executing function {}", "c2037_l2055_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2037_l2055_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2038_l2056_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2038_l2056_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2038_l2056_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2039_l2057_assert_return_canonical_nan");
+    println!("Executing function {}", "c2039_l2057_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2039_l2057_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2040_l2058_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2040_l2058_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2040_l2058_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -26615,113 +18906,89 @@ fn c2072_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 2091
 fn c2073_l2091_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2073_l2091_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2073_l2091_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2073_l2091_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2092
 fn c2074_l2092_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2074_l2092_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2074_l2092_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2074_l2092_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2093
 fn c2075_l2093_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2075_l2093_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2075_l2093_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2075_l2093_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2094
 fn c2076_l2094_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2076_l2094_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2076_l2094_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2076_l2094_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2095
 fn c2077_l2095_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2077_l2095_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2077_l2095_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2077_l2095_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2096
 fn c2078_l2096_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2078_l2096_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2078_l2096_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2078_l2096_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2097
 fn c2079_l2097_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2079_l2097_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2079_l2097_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2079_l2097_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2098
 fn c2080_l2098_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2080_l2098_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2080_l2098_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2080_l2098_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -26983,113 +19250,89 @@ fn c2112_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 2131
 fn c2113_l2131_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2113_l2131_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2113_l2131_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2113_l2131_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2132
 fn c2114_l2132_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2114_l2132_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2114_l2132_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2114_l2132_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2133
 fn c2115_l2133_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2115_l2133_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2115_l2133_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2115_l2133_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2134
 fn c2116_l2134_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2116_l2134_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2116_l2134_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2116_l2134_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2135
 fn c2117_l2135_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2117_l2135_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2117_l2135_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2117_l2135_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2136
 fn c2118_l2136_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2118_l2136_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2118_l2136_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2118_l2136_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2137
 fn c2119_l2137_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2119_l2137_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2119_l2137_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2119_l2137_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2138
 fn c2120_l2138_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2120_l2138_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2120_l2138_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2120_l2138_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -27256,10 +19499,7 @@ fn c2140_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -27267,10 +19507,7 @@ fn c2141_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -27278,10 +19515,7 @@ fn c2142_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -27289,10 +19523,7 @@ fn c2143_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -27332,10 +19563,7 @@ fn c2148_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -27351,10 +19579,7 @@ fn c2150_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -27369,185 +19594,89 @@ fn c2152_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2153_l2171_assert_return_canonical_nan");
+    println!("Executing function {}", "c2153_l2171_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2153_l2171_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2154_l2172_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2154_l2172_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2154_l2172_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2155_l2173_assert_return_canonical_nan");
+    println!("Executing function {}", "c2155_l2173_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2155_l2173_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2156_l2174_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2156_l2174_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2156_l2174_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2157_l2175_assert_return_canonical_nan");
+    println!("Executing function {}", "c2157_l2175_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2157_l2175_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2158_l2176_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2158_l2176_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2158_l2176_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2159_l2177_assert_return_canonical_nan");
+    println!("Executing function {}", "c2159_l2177_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2159_l2177_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2160_l2178_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2160_l2178_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2160_l2178_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -27714,10 +19843,7 @@ fn c2180_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -27725,10 +19851,7 @@ fn c2181_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -27736,10 +19859,7 @@ fn c2182_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -27747,10 +19867,7 @@ fn c2183_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -27790,10 +19907,7 @@ fn c2188_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -27809,10 +19923,7 @@ fn c2190_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -27827,195 +19938,96 @@ fn c2192_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2193_l2211_assert_return_canonical_nan");
+    println!("Executing function {}", "c2193_l2211_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2193_l2211_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2194_l2212_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2194_l2212_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2194_l2212_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2195_l2213_assert_return_canonical_nan");
+    println!("Executing function {}", "c2195_l2213_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2195_l2213_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2196_l2214_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2196_l2214_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2196_l2214_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2197_l2215_assert_return_canonical_nan");
+    println!("Executing function {}", "c2197_l2215_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2197_l2215_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2198_l2216_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2198_l2216_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2198_l2216_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2199_l2217_assert_return_canonical_nan");
+    println!("Executing function {}", "c2199_l2217_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2199_l2217_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2200_l2218_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2200_l2218_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2200_l2218_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -28023,10 +20035,7 @@ fn c2201_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -28034,10 +20043,7 @@ fn c2202_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28045,10 +20051,7 @@ fn c2203_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28120,10 +20123,7 @@ fn c2212_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -28131,10 +20131,7 @@ fn c2213_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -28142,10 +20139,7 @@ fn c2214_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28153,10 +20147,7 @@ fn c2215_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28164,10 +20155,7 @@ fn c2216_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -28175,10 +20163,7 @@ fn c2217_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -28186,10 +20171,7 @@ fn c2218_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28197,10 +20179,7 @@ fn c2219_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28208,13 +20187,7 @@ fn c2220_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28222,13 +20195,7 @@ fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28236,13 +20203,7 @@ fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28250,13 +20211,7 @@ fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28296,13 +20251,7 @@ fn c2228_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28310,13 +20259,7 @@ fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -28324,13 +20267,7 @@ fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -28338,198 +20275,96 @@ fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2233_l2251_assert_return_canonical_nan");
+    println!("Executing function {}", "c2233_l2251_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2233_l2251_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2234_l2252_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2234_l2252_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2234_l2252_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2235_l2253_assert_return_canonical_nan");
+    println!("Executing function {}", "c2235_l2253_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2235_l2253_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2236_l2254_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2236_l2254_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2236_l2254_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2237_l2255_assert_return_canonical_nan");
+    println!("Executing function {}", "c2237_l2255_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2237_l2255_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2238_l2256_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2238_l2256_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2238_l2256_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2239_l2257_assert_return_canonical_nan");
+    println!("Executing function {}", "c2239_l2257_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2239_l2257_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2240_l2258_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2240_l2258_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2240_l2258_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -28791,123 +20626,96 @@ fn c2272_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 2291
 fn c2273_l2291_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2273_l2291_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2273_l2291_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2273_l2291_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2292
 fn c2274_l2292_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2274_l2292_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2274_l2292_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2274_l2292_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2293
 fn c2275_l2293_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2275_l2293_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2275_l2293_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2275_l2293_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2294
 fn c2276_l2294_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2276_l2294_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2276_l2294_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2276_l2294_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2295
 fn c2277_l2295_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2277_l2295_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2277_l2295_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2277_l2295_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2296
 fn c2278_l2296_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2278_l2296_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2278_l2296_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2278_l2296_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2297
 fn c2279_l2297_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2279_l2297_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2279_l2297_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2279_l2297_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2298
 fn c2280_l2298_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2280_l2298_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2280_l2298_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2280_l2298_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -28915,10 +20723,7 @@ fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -29006,10 +20811,7 @@ fn c2292_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -29017,10 +20819,7 @@ fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.5f64))],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -29044,10 +20843,7 @@ fn c2296_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -29055,10 +20851,7 @@ fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((1.0f64))],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -29082,13 +20875,7 @@ fn c2300_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -29096,13 +20883,7 @@ fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -29110,13 +20891,7 @@ fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -29124,13 +20899,7 @@ fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -29170,10 +20939,7 @@ fn c2308_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -29181,10 +20947,7 @@ fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -29192,10 +20955,7 @@ fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -29203,1819 +20963,976 @@ fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2313_l2331_assert_return_canonical_nan");
+    println!("Executing function {}", "c2313_l2331_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2313_l2331_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2314_l2332_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2314_l2332_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2314_l2332_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2315_l2333_assert_return_canonical_nan");
+    println!("Executing function {}", "c2315_l2333_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2315_l2333_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2316_l2334_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2316_l2334_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2316_l2334_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2317_l2335_assert_return_canonical_nan");
+    println!("Executing function {}", "c2317_l2335_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2317_l2335_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2318_l2336_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2318_l2336_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2318_l2336_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2319_l2337_assert_return_canonical_nan");
+    println!("Executing function {}", "c2319_l2337_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2319_l2337_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2320_l2338_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2320_l2338_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2320_l2338_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2321_l2339_assert_return_canonical_nan");
+    println!("Executing function {}", "c2321_l2339_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c2321_l2339_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2322_l2340_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2322_l2340_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c2322_l2340_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2323_l2341_assert_return_canonical_nan");
+    println!("Executing function {}", "c2323_l2341_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c2323_l2341_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2324_l2342_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2324_l2342_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c2324_l2342_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2325_l2343_assert_return_canonical_nan");
+    println!("Executing function {}", "c2325_l2343_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c2325_l2343_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2326_l2344_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2326_l2344_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c2326_l2344_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2327_l2345_assert_return_canonical_nan");
+    println!("Executing function {}", "c2327_l2345_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c2327_l2345_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2328_l2346_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2328_l2346_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c2328_l2346_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2347
 fn c2329_l2347_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2329_l2347_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2329_l2347_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2329_l2347_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2348
 fn c2330_l2348_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2330_l2348_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2330_l2348_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2330_l2348_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2349
 fn c2331_l2349_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2331_l2349_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2331_l2349_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2331_l2349_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2350
 fn c2332_l2350_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2332_l2350_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2332_l2350_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2332_l2350_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2351
 fn c2333_l2351_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2333_l2351_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2333_l2351_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2333_l2351_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2352
 fn c2334_l2352_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2334_l2352_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2334_l2352_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2334_l2352_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2353
 fn c2335_l2353_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2335_l2353_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2335_l2353_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2335_l2353_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2354
 fn c2336_l2354_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2336_l2354_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2336_l2354_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2336_l2354_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2355
 fn c2337_l2355_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2337_l2355_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2337_l2355_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2337_l2355_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2356
 fn c2338_l2356_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2338_l2356_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2338_l2356_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2338_l2356_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2357
 fn c2339_l2357_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2339_l2357_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2339_l2357_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2339_l2357_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2358
 fn c2340_l2358_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2340_l2358_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2340_l2358_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2340_l2358_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2359
 fn c2341_l2359_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2341_l2359_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2341_l2359_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2341_l2359_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2360
 fn c2342_l2360_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2342_l2360_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2342_l2360_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2342_l2360_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2361
 fn c2343_l2361_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2343_l2361_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2343_l2361_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2343_l2361_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2362
 fn c2344_l2362_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2344_l2362_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2344_l2362_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2344_l2362_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2345_l2363_assert_return_canonical_nan");
+    println!("Executing function {}", "c2345_l2363_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2345_l2363_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2346_l2364_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2346_l2364_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2346_l2364_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2347_l2365_assert_return_canonical_nan");
+    println!("Executing function {}", "c2347_l2365_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c2347_l2365_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2348_l2366_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2348_l2366_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c2348_l2366_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2349_l2367_assert_return_canonical_nan");
+    println!("Executing function {}", "c2349_l2367_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2349_l2367_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2350_l2368_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2350_l2368_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2350_l2368_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2351_l2369_assert_return_canonical_nan");
+    println!("Executing function {}", "c2351_l2369_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c2351_l2369_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((0.5f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2352_l2370_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2352_l2370_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c2352_l2370_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2353_l2371_assert_return_canonical_nan");
+    println!("Executing function {}", "c2353_l2371_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2353_l2371_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2354_l2372_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2354_l2372_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2354_l2372_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2355_l2373_assert_return_canonical_nan");
+    println!("Executing function {}", "c2355_l2373_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c2355_l2373_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2356_l2374_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2356_l2374_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c2356_l2374_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2357_l2375_assert_return_canonical_nan");
+    println!("Executing function {}", "c2357_l2375_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2357_l2375_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2358_l2376_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2358_l2376_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2358_l2376_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2359_l2377_assert_return_canonical_nan");
+    println!("Executing function {}", "c2359_l2377_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c2359_l2377_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((1.0f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2360_l2378_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2360_l2378_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c2360_l2378_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2361_l2379_assert_return_canonical_nan");
+    println!("Executing function {}", "c2361_l2379_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2361_l2379_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2362_l2380_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2362_l2380_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2362_l2380_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2363_l2381_assert_return_canonical_nan");
+    println!("Executing function {}", "c2363_l2381_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c2363_l2381_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2364_l2382_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2364_l2382_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c2364_l2382_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2365_l2383_assert_return_canonical_nan");
+    println!("Executing function {}", "c2365_l2383_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2365_l2383_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((-6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2366_l2384_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2366_l2384_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2366_l2384_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2367_l2385_assert_return_canonical_nan");
+    println!("Executing function {}", "c2367_l2385_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c2367_l2385_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64((6.283185307179586f64)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2368_l2386_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2368_l2386_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c2368_l2386_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2387
 fn c2369_l2387_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2369_l2387_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2369_l2387_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2369_l2387_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2388
 fn c2370_l2388_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2370_l2388_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2370_l2388_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2370_l2388_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2389
 fn c2371_l2389_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2371_l2389_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2371_l2389_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2371_l2389_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2390
 fn c2372_l2390_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2372_l2390_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2372_l2390_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2372_l2390_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2391
 fn c2373_l2391_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2373_l2391_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2373_l2391_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2373_l2391_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2392
 fn c2374_l2392_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2374_l2392_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2374_l2392_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2374_l2392_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2393
 fn c2375_l2393_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2375_l2393_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2375_l2393_assert_return_canonical_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2375_l2393_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
 // Line 2394
 fn c2376_l2394_assert_return_arithmetic_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2376_l2394_assert_return_arithmetic_nan"
-    );
+    println!("Executing function {}", "c2376_l2394_assert_return_arithmetic_nan");
     let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2376_l2394_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2377_l2395_assert_return_canonical_nan");
+    println!("Executing function {}", "c2377_l2395_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2377_l2395_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2378_l2396_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2378_l2396_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2378_l2396_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2379_l2397_assert_return_canonical_nan");
+    println!("Executing function {}", "c2379_l2397_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c2379_l2397_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2380_l2398_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2380_l2398_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c2380_l2398_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2381_l2399_assert_return_canonical_nan");
+    println!("Executing function {}", "c2381_l2399_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2381_l2399_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::NEG_INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2382_l2400_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2382_l2400_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2382_l2400_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2383_l2401_assert_return_canonical_nan");
+    println!("Executing function {}", "c2383_l2401_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c2383_l2401_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::INFINITY),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2384_l2402_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2384_l2402_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c2384_l2402_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2385_l2403_assert_return_canonical_nan");
+    println!("Executing function {}", "c2385_l2403_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2385_l2403_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2386_l2404_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2386_l2404_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2386_l2404_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2387_l2405_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2387_l2405_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2387_l2405_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2388_l2406_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2388_l2406_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2388_l2406_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2389_l2407_assert_return_canonical_nan");
+    println!("Executing function {}", "c2389_l2407_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2389_l2407_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2390_l2408_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2390_l2408_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2390_l2408_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2391_l2409_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2391_l2409_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2391_l2409_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2392_l2410_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2392_l2410_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2392_l2410_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2393_l2411_assert_return_canonical_nan");
+    println!("Executing function {}", "c2393_l2411_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2393_l2411_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18444492273895866368)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2394_l2412_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2394_l2412_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2394_l2412_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2395_l2413_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2395_l2413_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2395_l2413_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(18443366373989023744)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2396_l2414_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2396_l2414_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2396_l2414_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2397_l2415_assert_return_canonical_nan");
+    println!("Executing function {}", "c2397_l2415_assert_return_canonical_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2397_l2415_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9221120237041090560)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2398_l2416_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2398_l2416_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2398_l2416_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2399_l2417_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2399_l2417_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2399_l2417_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-                Value::F64(f64::from_bits(9219994337134247936)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c2400_l2418_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2400_l2418_assert_return_arithmetic_nan");
+    let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2400_l2418_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31037,15 +21954,12 @@ fn c2402_l2420_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 2421
 fn c2403_l2421_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2403_l2421_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2403_l2421_assert_return_canonical_nan");
     let result = instance.call("sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2403_l2421_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31059,15 +21973,12 @@ fn c2404_l2422_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 2423
 fn c2405_l2423_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2405_l2423_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2405_l2423_assert_return_canonical_nan");
     let result = instance.call("sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2405_l2423_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31081,18 +21992,12 @@ fn c2406_l2424_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2407_l2425_assert_return_canonical_nan");
+    println!("Executing function {}", "c2407_l2425_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2407_l2425_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31106,18 +22011,12 @@ fn c2408_l2426_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2409_l2427_assert_return_canonical_nan");
+    println!("Executing function {}", "c2409_l2427_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2409_l2427_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31131,18 +22030,12 @@ fn c2410_l2428_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2411_l2429_assert_return_canonical_nan");
+    println!("Executing function {}", "c2411_l2429_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2411_l2429_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31156,15 +22049,12 @@ fn c2412_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 2431
 fn c2413_l2431_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c2413_l2431_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c2413_l2431_assert_return_canonical_nan");
     let result = instance.call("sqrt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2413_l2431_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31178,18 +22068,12 @@ fn c2414_l2432_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)])
-        .unwrap()
-        .expect("Missing result in c2415_l2433_assert_return_canonical_nan");
+    println!("Executing function {}", "c2415_l2433_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2415_l2433_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31203,69 +22087,45 @@ fn c2416_l2434_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2417_l2435_assert_return_canonical_nan");
+    println!("Executing function {}", "c2417_l2435_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2417_l2435_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2418_l2436_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2418_l2436_assert_return_arithmetic_nan");
+    let result = instance.call("sqrt", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2418_l2436_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2419_l2437_assert_return_canonical_nan");
+    println!("Executing function {}", "c2419_l2437_assert_return_canonical_nan");
+    let result = instance.call("sqrt", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2419_l2437_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2420_l2438_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2420_l2438_assert_return_arithmetic_nan");
+    let result = instance.call("sqrt", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2420_l2438_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31399,69 +22259,45 @@ fn c2436_l2454_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2437_l2455_assert_return_canonical_nan");
+    println!("Executing function {}", "c2437_l2455_assert_return_canonical_nan");
+    let result = instance.call("floor", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2437_l2455_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2438_l2456_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2438_l2456_assert_return_arithmetic_nan");
+    let result = instance.call("floor", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2438_l2456_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2439_l2457_assert_return_canonical_nan");
+    println!("Executing function {}", "c2439_l2457_assert_return_canonical_nan");
+    let result = instance.call("floor", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2439_l2457_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2440_l2458_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2440_l2458_assert_return_arithmetic_nan");
+    let result = instance.call("floor", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2440_l2458_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31595,69 +22431,45 @@ fn c2456_l2474_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2457_l2475_assert_return_canonical_nan");
+    println!("Executing function {}", "c2457_l2475_assert_return_canonical_nan");
+    let result = instance.call("ceil", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2457_l2475_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2458_l2476_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2458_l2476_assert_return_arithmetic_nan");
+    let result = instance.call("ceil", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2458_l2476_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2459_l2477_assert_return_canonical_nan");
+    println!("Executing function {}", "c2459_l2477_assert_return_canonical_nan");
+    let result = instance.call("ceil", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2459_l2477_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2460_l2478_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2460_l2478_assert_return_arithmetic_nan");
+    let result = instance.call("ceil", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2460_l2478_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31791,69 +22603,45 @@ fn c2476_l2494_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c2477_l2495_assert_return_canonical_nan");
+    println!("Executing function {}", "c2477_l2495_assert_return_canonical_nan");
+    let result = instance.call("trunc", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2477_l2495_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2478_l2496_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2478_l2496_assert_return_arithmetic_nan");
+    let result = instance.call("trunc", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2478_l2496_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2479_l2497_assert_return_canonical_nan");
+    println!("Executing function {}", "c2479_l2497_assert_return_canonical_nan");
+    let result = instance.call("trunc", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2479_l2497_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c2480_l2498_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2480_l2498_assert_return_arithmetic_nan");
+    let result = instance.call("trunc", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2480_l2498_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -31987,81 +22775,45 @@ fn c2496_l2514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c2497_l2515_assert_return_canonical_nan");
+    println!("Executing function {}", "c2497_l2515_assert_return_canonical_nan");
+    let result = instance.call("nearest", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2497_l2515_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c2498_l2516_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2498_l2516_assert_return_arithmetic_nan");
+    let result = instance.call("nearest", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2498_l2516_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c2499_l2517_assert_return_canonical_nan");
+    println!("Executing function {}", "c2499_l2517_assert_return_canonical_nan");
+    let result = instance.call("nearest", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2499_l2517_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c2500_l2518_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c2500_l2518_assert_return_arithmetic_nan");
+    let result = instance.call("nearest", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2500_l2518_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
diff --git a/lib/runtime/tests/spectests/f64_bitwise.rs b/lib/runtime/tests/spectests/f64_bitwise.rs
index 79053a938..e952f9244 100644
--- a/lib/runtime/tests/spectests/f64_bitwise.rs
+++ b/lib/runtime/tests/spectests/f64_bitwise.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 4
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64) (result f64)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -34,11 +38,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -209,10 +210,7 @@ fn c20_l29_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -220,10 +218,7 @@ fn c21_l30_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -231,10 +226,7 @@ fn c22_l31_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -242,10 +234,7 @@ fn c23_l32_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -285,10 +274,7 @@ fn c28_l37_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -296,10 +282,7 @@ fn c29_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -307,10 +290,7 @@ fn c30_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -318,10 +298,7 @@ fn c31_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -329,13 +306,7 @@ fn c32_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -343,13 +314,7 @@ fn c33_l42_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -357,13 +322,7 @@ fn c34_l43_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -371,13 +330,7 @@ fn c35_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -1121,10 +1074,7 @@ fn c128_l137_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -1132,10 +1082,7 @@ fn c129_l138_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -1143,10 +1090,7 @@ fn c130_l139_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -1154,10 +1098,7 @@ fn c131_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -1197,10 +1138,7 @@ fn c136_l145_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -1208,10 +1146,7 @@ fn c137_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -1219,10 +1154,7 @@ fn c138_l147_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -1230,10 +1162,7 @@ fn c139_l148_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -1241,13 +1170,7 @@ fn c140_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -1255,13 +1178,7 @@ fn c141_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -1269,13 +1186,7 @@ fn c142_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.5f64)))));
     result.map(|_| ())
 }
@@ -1283,13 +1194,7 @@ fn c143_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64((0.5f64)))));
     result.map(|_| ())
 }
@@ -1457,10 +1362,7 @@ fn c164_l173_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -1468,10 +1370,7 @@ fn c165_l174_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1479,10 +1378,7 @@ fn c166_l175_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -1490,10 +1386,7 @@ fn c167_l176_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1533,10 +1426,7 @@ fn c172_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -1544,10 +1434,7 @@ fn c173_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1555,10 +1442,7 @@ fn c174_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -1566,10 +1450,7 @@ fn c175_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1577,13 +1458,7 @@ fn c176_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -1591,13 +1466,7 @@ fn c177_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1605,13 +1474,7 @@ fn c178_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -1619,13 +1482,7 @@ fn c179_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1633,10 +1490,7 @@ fn c180_l189_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1644,10 +1498,7 @@ fn c181_l190_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1655,10 +1506,7 @@ fn c182_l191_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1666,10 +1514,7 @@ fn c183_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1741,10 +1586,7 @@ fn c192_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1752,10 +1594,7 @@ fn c193_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1763,10 +1602,7 @@ fn c194_l203_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1774,10 +1610,7 @@ fn c195_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1785,10 +1618,7 @@ fn c196_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1796,10 +1626,7 @@ fn c197_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1807,10 +1634,7 @@ fn c198_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1818,10 +1642,7 @@ fn c199_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1829,13 +1650,7 @@ fn c200_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1843,13 +1658,7 @@ fn c201_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1857,13 +1666,7 @@ fn c202_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1871,13 +1674,7 @@ fn c203_l212_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1917,13 +1714,7 @@ fn c208_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1931,13 +1722,7 @@ fn c209_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1945,13 +1730,7 @@ fn c210_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1959,13 +1738,7 @@ fn c211_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1973,13 +1746,7 @@ fn c212_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -1987,13 +1754,7 @@ fn c213_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2001,13 +1762,7 @@ fn c214_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2015,13 +1770,7 @@ fn c215_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64)))));
     result.map(|_| ())
 }
@@ -2317,10 +2066,7 @@ fn c252_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2328,10 +2074,7 @@ fn c253_l262_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2339,10 +2082,7 @@ fn c254_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2350,10 +2090,7 @@ fn c255_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2425,10 +2162,7 @@ fn c264_l273_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2436,10 +2170,7 @@ fn c265_l274_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.5f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2447,10 +2178,7 @@ fn c266_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2458,10 +2186,7 @@ fn c267_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((0.5f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2469,10 +2194,7 @@ fn c268_l277_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2480,10 +2202,7 @@ fn c269_l278_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((1.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2491,10 +2210,7 @@ fn c270_l279_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2502,10 +2218,7 @@ fn c271_l280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((1.0f64))],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2513,13 +2226,7 @@ fn c272_l281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2527,13 +2234,7 @@ fn c273_l282_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2541,13 +2242,7 @@ fn c274_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2555,13 +2250,7 @@ fn c275_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2601,10 +2290,7 @@ fn c280_l289_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2612,10 +2298,7 @@ fn c281_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2623,10 +2306,7 @@ fn c282_l291_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2634,10 +2314,7 @@ fn c283_l292_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2645,13 +2322,7 @@ fn c284_l293_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2659,13 +2330,7 @@ fn c285_l294_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2673,13 +2338,7 @@ fn c286_l295_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2687,13 +2346,7 @@ fn c287_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY))));
     result.map(|_| ())
 }
@@ -2701,92 +2354,56 @@ fn c288_l297_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]);
     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);
-    }
+                                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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -2795,15 +2412,12 @@ 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -2812,15 +2426,12 @@ 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -2829,15 +2440,12 @@ 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -2846,15 +2454,12 @@ 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -2863,15 +2468,12 @@ 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -2880,15 +2482,12 @@ 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -2897,15 +2496,12 @@ 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -2914,291 +2510,180 @@ 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]);
     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);
-    }
+                                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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]);
     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);
-    }
+                                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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]);
     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);
-    }
+                                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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]);
     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);
-    }
+                                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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]);
     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);
-    }
+                                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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]);
     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);
-    }
+                                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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]);
     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);
-    }
+                                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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]);
     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);
-    }
+                                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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]);
     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);
-    }
+                                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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]);
     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);
-    }
+                                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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]);
     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);
-    }
+                                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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]);
     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);
-    }
+                                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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -3207,15 +2692,12 @@ 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)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -3224,15 +2706,12 @@ 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)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -3241,15 +2720,12 @@ 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)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -3258,199 +2734,124 @@ 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)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
     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);
-    }
+                                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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]);
     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);
-    }
+                                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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]);
     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);
-    }
+                                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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]);
     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);
-    }
+                                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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]);
     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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -3587,15 +2988,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -3604,15 +3002,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -3749,15 +3144,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -3766,15 +3158,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
diff --git a/lib/runtime/tests/spectests/f64_cmp.rs b/lib/runtime/tests/spectests/f64_cmp.rs
index d643b902e..fb5f7c2a6 100644
--- a/lib/runtime/tests/spectests/f64_cmp.rs
+++ b/lib/runtime/tests/spectests/f64_cmp.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 4
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64 f64) (result i32)))
       (func (;0;) (type 0) (param f64 f64) (result i32)
@@ -50,11 +54,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -225,10 +226,7 @@ fn c20_l32_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -236,10 +234,7 @@ fn c21_l33_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -247,10 +242,7 @@ fn c22_l34_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -258,10 +250,7 @@ fn c23_l35_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -301,10 +290,7 @@ fn c28_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -336,13 +322,7 @@ fn c32_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -350,13 +330,7 @@ fn c33_l45_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -364,13 +338,7 @@ fn c34_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -378,13 +346,7 @@ fn c35_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -392,13 +354,7 @@ fn c36_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -406,13 +362,7 @@ fn c37_l49_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -420,13 +370,7 @@ fn c38_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -434,13 +378,7 @@ fn c39_l51_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1248,10 +1186,7 @@ fn c140_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1259,10 +1194,7 @@ fn c141_l153_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1270,10 +1202,7 @@ fn c142_l154_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1281,10 +1210,7 @@ fn c143_l155_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1324,10 +1250,7 @@ fn c148_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1359,13 +1282,7 @@ fn c152_l164_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1373,13 +1290,7 @@ fn c153_l165_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1387,13 +1298,7 @@ fn c154_l166_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1401,13 +1306,7 @@ fn c155_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1415,13 +1314,7 @@ fn c156_l168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1429,13 +1322,7 @@ fn c157_l169_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1443,13 +1330,7 @@ fn c158_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1457,13 +1338,7 @@ fn c159_l171_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1631,10 +1506,7 @@ fn c180_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1642,10 +1514,7 @@ fn c181_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1653,10 +1522,7 @@ fn c182_l194_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1664,10 +1530,7 @@ fn c183_l195_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1707,10 +1570,7 @@ fn c188_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1742,13 +1602,7 @@ fn c192_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1756,13 +1610,7 @@ fn c193_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1770,13 +1618,7 @@ fn c194_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1784,13 +1626,7 @@ fn c195_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1798,13 +1634,7 @@ fn c196_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1812,13 +1642,7 @@ fn c197_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1826,13 +1650,7 @@ fn c198_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1840,13 +1658,7 @@ fn c199_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1854,10 +1666,7 @@ fn c200_l212_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1865,10 +1674,7 @@ fn c201_l213_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1876,10 +1682,7 @@ fn c202_l214_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1887,10 +1690,7 @@ fn c203_l215_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1962,10 +1762,7 @@ fn c212_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1973,10 +1770,7 @@ fn c213_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1984,10 +1778,7 @@ fn c214_l226_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1995,10 +1786,7 @@ fn c215_l227_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2006,10 +1794,7 @@ fn c216_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2017,10 +1802,7 @@ fn c217_l229_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2028,10 +1810,7 @@ fn c218_l230_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2039,10 +1818,7 @@ fn c219_l231_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2050,13 +1826,7 @@ fn c220_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -2064,13 +1834,7 @@ fn c221_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2078,13 +1842,7 @@ fn c222_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2092,13 +1850,7 @@ fn c223_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -2138,13 +1890,7 @@ fn c228_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2152,13 +1898,7 @@ fn c229_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2166,13 +1906,7 @@ fn c230_l242_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2180,13 +1914,7 @@ fn c231_l243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2194,13 +1922,7 @@ fn c232_l244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2208,13 +1930,7 @@ fn c233_l245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2222,13 +1938,7 @@ fn c234_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2236,13 +1946,7 @@ fn c235_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2250,13 +1954,7 @@ fn c236_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2264,13 +1962,7 @@ fn c237_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2278,13 +1970,7 @@ fn c238_l250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2292,13 +1978,7 @@ fn c239_l251_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2626,10 +2306,7 @@ fn c280_l292_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2725,10 +2402,7 @@ fn c292_l304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2760,10 +2434,7 @@ fn c296_l308_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2795,13 +2466,7 @@ fn c300_l312_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2809,13 +2474,7 @@ fn c301_l313_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2823,13 +2482,7 @@ fn c302_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2837,13 +2490,7 @@ fn c303_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2883,10 +2530,7 @@ fn c308_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -2894,10 +2538,7 @@ fn c309_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2905,10 +2546,7 @@ fn c310_l322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2916,10 +2554,7 @@ fn c311_l323_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -2927,13 +2562,7 @@ fn c312_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2941,13 +2570,7 @@ fn c313_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2955,13 +2578,7 @@ fn c314_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2969,13 +2586,7 @@ fn c315_l327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2983,13 +2594,7 @@ fn c316_l328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -2997,13 +2602,7 @@ fn c317_l329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3011,13 +2610,7 @@ fn c318_l330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3025,13 +2618,7 @@ fn c319_l331_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3039,13 +2626,7 @@ fn c320_l332_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3053,13 +2634,7 @@ fn c321_l333_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3067,13 +2642,7 @@ fn c322_l334_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3081,13 +2650,7 @@ fn c323_l335_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3095,13 +2658,7 @@ fn c324_l336_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3109,13 +2666,7 @@ fn c325_l337_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3123,13 +2674,7 @@ fn c326_l338_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3137,13 +2682,7 @@ fn c327_l339_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3279,13 +2818,7 @@ fn c344_l356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3293,13 +2826,7 @@ fn c345_l357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3307,13 +2834,7 @@ fn c346_l358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3321,13 +2842,7 @@ fn c347_l359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3335,13 +2850,7 @@ fn c348_l360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3349,13 +2858,7 @@ fn c349_l361_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3363,13 +2866,7 @@ fn c350_l362_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3377,13 +2874,7 @@ fn c351_l363_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3391,13 +2882,7 @@ fn c352_l364_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3405,13 +2890,7 @@ fn c353_l365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3419,13 +2898,7 @@ fn c354_l366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3433,13 +2906,7 @@ fn c355_l367_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3447,13 +2914,7 @@ fn c356_l368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3461,13 +2922,7 @@ fn c357_l369_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3475,13 +2930,7 @@ fn c358_l370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3489,13 +2938,7 @@ fn c359_l371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3503,13 +2946,7 @@ fn c360_l372_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3517,13 +2954,7 @@ fn c361_l373_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3531,13 +2962,7 @@ fn c362_l374_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3545,13 +2970,7 @@ fn c363_l375_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3559,13 +2978,7 @@ fn c364_l376_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3573,13 +2986,7 @@ fn c365_l377_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3587,13 +2994,7 @@ fn c366_l378_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3601,13 +3002,7 @@ fn c367_l379_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3679,13 +3074,7 @@ fn c376_l388_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3693,13 +3082,7 @@ fn c377_l389_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3707,13 +3090,7 @@ fn c378_l390_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3721,13 +3098,7 @@ fn c379_l391_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3735,13 +3106,7 @@ fn c380_l392_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3749,13 +3114,7 @@ fn c381_l393_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3763,13 +3122,7 @@ fn c382_l394_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3777,13 +3130,7 @@ fn c383_l395_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3791,13 +3138,7 @@ fn c384_l396_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3805,13 +3146,7 @@ fn c385_l397_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3819,13 +3154,7 @@ fn c386_l398_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3833,13 +3162,7 @@ fn c387_l399_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3847,13 +3170,7 @@ fn c388_l400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3861,13 +3178,7 @@ fn c389_l401_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3875,13 +3186,7 @@ fn c390_l402_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3889,13 +3194,7 @@ fn c391_l403_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3903,13 +3202,7 @@ fn c392_l404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3917,13 +3210,7 @@ fn c393_l405_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3931,13 +3218,7 @@ fn c394_l406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3945,13 +3226,7 @@ fn c395_l407_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3959,13 +3234,7 @@ fn c396_l408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3973,13 +3242,7 @@ fn c397_l409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -3987,13 +3250,7 @@ fn c398_l410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4001,13 +3258,7 @@ fn c399_l411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -4175,10 +3426,7 @@ fn c420_l432_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4186,10 +3434,7 @@ fn c421_l433_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4197,10 +3442,7 @@ fn c422_l434_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4208,10 +3450,7 @@ fn c423_l435_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4251,10 +3490,7 @@ fn c428_l440_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4286,13 +3522,7 @@ fn c432_l444_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4300,13 +3530,7 @@ fn c433_l445_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4314,13 +3538,7 @@ fn c434_l446_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4328,13 +3546,7 @@ fn c435_l447_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4342,13 +3554,7 @@ fn c436_l448_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4356,13 +3562,7 @@ fn c437_l449_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4370,13 +3570,7 @@ fn c438_l450_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -4384,13 +3578,7 @@ fn c439_l451_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5198,10 +4386,7 @@ fn c540_l552_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5209,10 +4394,7 @@ fn c541_l553_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5220,10 +4402,7 @@ fn c542_l554_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5231,10 +4410,7 @@ fn c543_l555_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5274,10 +4450,7 @@ fn c548_l560_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5309,13 +4482,7 @@ fn c552_l564_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5323,13 +4490,7 @@ fn c553_l565_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5337,13 +4498,7 @@ fn c554_l566_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5351,13 +4506,7 @@ fn c555_l567_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5365,13 +4514,7 @@ fn c556_l568_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5379,13 +4522,7 @@ fn c557_l569_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5393,13 +4530,7 @@ fn c558_l570_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5407,13 +4538,7 @@ fn c559_l571_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5581,10 +4706,7 @@ fn c580_l592_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5592,10 +4714,7 @@ fn c581_l593_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5603,10 +4722,7 @@ fn c582_l594_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5614,10 +4730,7 @@ fn c583_l595_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5657,10 +4770,7 @@ fn c588_l600_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5692,13 +4802,7 @@ fn c592_l604_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5706,13 +4810,7 @@ fn c593_l605_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5720,13 +4818,7 @@ fn c594_l606_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5734,13 +4826,7 @@ fn c595_l607_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5748,13 +4834,7 @@ fn c596_l608_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5762,13 +4842,7 @@ fn c597_l609_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5776,13 +4850,7 @@ fn c598_l610_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5790,13 +4858,7 @@ fn c599_l611_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5804,10 +4866,7 @@ fn c600_l612_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5815,10 +4874,7 @@ fn c601_l613_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5826,10 +4882,7 @@ fn c602_l614_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5837,10 +4890,7 @@ fn c603_l615_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5912,10 +4962,7 @@ fn c612_l624_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5923,10 +4970,7 @@ fn c613_l625_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5934,10 +4978,7 @@ fn c614_l626_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5945,10 +4986,7 @@ fn c615_l627_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5956,10 +4994,7 @@ fn c616_l628_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5967,10 +5002,7 @@ fn c617_l629_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5978,10 +5010,7 @@ fn c618_l630_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -5989,10 +5018,7 @@ fn c619_l631_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6000,13 +5026,7 @@ fn c620_l632_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -6014,13 +5034,7 @@ fn c621_l633_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6028,13 +5042,7 @@ fn c622_l634_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6042,13 +5050,7 @@ fn c623_l635_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -6088,13 +5090,7 @@ fn c628_l640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6102,13 +5098,7 @@ fn c629_l641_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6116,13 +5106,7 @@ fn c630_l642_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6130,13 +5114,7 @@ fn c631_l643_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6144,13 +5122,7 @@ fn c632_l644_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6158,13 +5130,7 @@ fn c633_l645_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6172,13 +5138,7 @@ fn c634_l646_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6186,13 +5146,7 @@ fn c635_l647_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6200,13 +5154,7 @@ fn c636_l648_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6214,13 +5162,7 @@ fn c637_l649_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6228,13 +5170,7 @@ fn c638_l650_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6242,13 +5178,7 @@ fn c639_l651_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6576,10 +5506,7 @@ fn c680_l692_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6675,10 +5602,7 @@ fn c692_l704_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6710,10 +5634,7 @@ fn c696_l708_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6745,13 +5666,7 @@ fn c700_l712_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6759,13 +5674,7 @@ fn c701_l713_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6773,13 +5682,7 @@ fn c702_l714_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6787,13 +5690,7 @@ fn c703_l715_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6833,10 +5730,7 @@ fn c708_l720_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -6844,10 +5738,7 @@ fn c709_l721_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6855,10 +5746,7 @@ fn c710_l722_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6866,10 +5754,7 @@ fn c711_l723_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -6877,13 +5762,7 @@ fn c712_l724_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6891,13 +5770,7 @@ fn c713_l725_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6905,13 +5778,7 @@ fn c714_l726_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6919,13 +5786,7 @@ fn c715_l727_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6933,13 +5794,7 @@ fn c716_l728_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6947,13 +5802,7 @@ fn c717_l729_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6961,13 +5810,7 @@ fn c718_l730_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6975,13 +5818,7 @@ fn c719_l731_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6989,13 +5826,7 @@ fn c720_l732_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7003,13 +5834,7 @@ fn c721_l733_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7017,13 +5842,7 @@ fn c722_l734_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7031,13 +5850,7 @@ fn c723_l735_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7045,13 +5858,7 @@ fn c724_l736_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7059,13 +5866,7 @@ fn c725_l737_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7073,13 +5874,7 @@ fn c726_l738_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7087,13 +5882,7 @@ fn c727_l739_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7229,13 +6018,7 @@ fn c744_l756_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7243,13 +6026,7 @@ fn c745_l757_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7257,13 +6034,7 @@ fn c746_l758_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7271,13 +6042,7 @@ fn c747_l759_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7285,13 +6050,7 @@ fn c748_l760_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7299,13 +6058,7 @@ fn c749_l761_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7313,13 +6066,7 @@ fn c750_l762_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7327,13 +6074,7 @@ fn c751_l763_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7341,13 +6082,7 @@ fn c752_l764_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7355,13 +6090,7 @@ fn c753_l765_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7369,13 +6098,7 @@ fn c754_l766_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7383,13 +6106,7 @@ fn c755_l767_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7397,13 +6114,7 @@ fn c756_l768_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7411,13 +6122,7 @@ fn c757_l769_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7425,13 +6130,7 @@ fn c758_l770_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7439,13 +6138,7 @@ fn c759_l771_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7453,13 +6146,7 @@ fn c760_l772_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7467,13 +6154,7 @@ fn c761_l773_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7481,13 +6162,7 @@ fn c762_l774_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7495,13 +6170,7 @@ fn c763_l775_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7509,13 +6178,7 @@ fn c764_l776_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7523,13 +6186,7 @@ fn c765_l777_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7537,13 +6194,7 @@ fn c766_l778_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7551,13 +6202,7 @@ fn c767_l779_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7629,13 +6274,7 @@ fn c776_l788_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7643,13 +6282,7 @@ fn c777_l789_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7657,13 +6290,7 @@ fn c778_l790_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7671,13 +6298,7 @@ fn c779_l791_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7685,13 +6306,7 @@ fn c780_l792_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7699,13 +6314,7 @@ fn c781_l793_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7713,13 +6322,7 @@ fn c782_l794_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7727,13 +6330,7 @@ fn c783_l795_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7741,13 +6338,7 @@ fn c784_l796_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7755,13 +6346,7 @@ fn c785_l797_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7769,13 +6354,7 @@ fn c786_l798_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7783,13 +6362,7 @@ fn c787_l799_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7797,13 +6370,7 @@ fn c788_l800_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7811,13 +6378,7 @@ fn c789_l801_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7825,13 +6386,7 @@ fn c790_l802_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7839,13 +6394,7 @@ fn c791_l803_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7853,13 +6402,7 @@ fn c792_l804_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7867,13 +6410,7 @@ fn c793_l805_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7881,13 +6418,7 @@ fn c794_l806_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7895,13 +6426,7 @@ fn c795_l807_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7909,13 +6434,7 @@ fn c796_l808_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7923,13 +6442,7 @@ fn c797_l809_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7937,13 +6450,7 @@ fn c798_l810_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -7951,13 +6458,7 @@ fn c799_l811_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8125,10 +6626,7 @@ fn c820_l832_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8136,10 +6634,7 @@ fn c821_l833_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8147,10 +6642,7 @@ fn c822_l834_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8158,10 +6650,7 @@ fn c823_l835_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -8201,10 +6690,7 @@ fn c828_l840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8236,13 +6722,7 @@ fn c832_l844_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8250,13 +6730,7 @@ fn c833_l845_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8264,13 +6738,7 @@ fn c834_l846_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8278,13 +6746,7 @@ fn c835_l847_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8292,13 +6754,7 @@ fn c836_l848_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8306,13 +6762,7 @@ fn c837_l849_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8320,13 +6770,7 @@ fn c838_l850_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -8334,13 +6778,7 @@ fn c839_l851_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9148,10 +7586,7 @@ fn c940_l952_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9159,10 +7594,7 @@ fn c941_l953_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9170,10 +7602,7 @@ fn c942_l954_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9181,10 +7610,7 @@ fn c943_l955_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9224,10 +7650,7 @@ fn c948_l960_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9259,13 +7682,7 @@ fn c952_l964_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9273,13 +7690,7 @@ fn c953_l965_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9287,13 +7698,7 @@ fn c954_l966_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9301,13 +7706,7 @@ fn c955_l967_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9315,13 +7714,7 @@ fn c956_l968_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9329,13 +7722,7 @@ fn c957_l969_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9343,13 +7730,7 @@ fn c958_l970_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9357,13 +7738,7 @@ fn c959_l971_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9531,10 +7906,7 @@ fn c980_l992_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9542,10 +7914,7 @@ fn c981_l993_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9553,10 +7922,7 @@ fn c982_l994_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9564,10 +7930,7 @@ fn c983_l995_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9607,10 +7970,7 @@ fn c988_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9642,13 +8002,7 @@ fn c992_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9656,13 +8010,7 @@ fn c993_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9670,13 +8018,7 @@ fn c994_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9684,13 +8026,7 @@ fn c995_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9698,13 +8034,7 @@ fn c996_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9712,13 +8042,7 @@ fn c997_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9726,13 +8050,7 @@ fn c998_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9740,13 +8058,7 @@ fn c999_l1011_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9754,10 +8066,7 @@ fn c1000_l1012_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9765,10 +8074,7 @@ fn c1001_l1013_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9776,10 +8082,7 @@ fn c1002_l1014_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9787,10 +8090,7 @@ fn c1003_l1015_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9862,10 +8162,7 @@ fn c1012_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9873,10 +8170,7 @@ fn c1013_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9884,10 +8178,7 @@ fn c1014_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9895,10 +8186,7 @@ fn c1015_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9906,10 +8194,7 @@ fn c1016_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9917,10 +8202,7 @@ fn c1017_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9928,10 +8210,7 @@ fn c1018_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9939,10 +8218,7 @@ fn c1019_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9950,13 +8226,7 @@ fn c1020_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9964,13 +8234,7 @@ fn c1021_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -9978,13 +8242,7 @@ fn c1022_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -9992,13 +8250,7 @@ fn c1023_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10038,13 +8290,7 @@ fn c1028_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10052,13 +8298,7 @@ fn c1029_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10066,13 +8306,7 @@ fn c1030_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10080,13 +8314,7 @@ fn c1031_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10094,13 +8322,7 @@ fn c1032_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10108,13 +8330,7 @@ fn c1033_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10122,13 +8338,7 @@ fn c1034_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10136,13 +8346,7 @@ fn c1035_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10150,13 +8354,7 @@ fn c1036_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10164,13 +8362,7 @@ fn c1037_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10178,13 +8370,7 @@ fn c1038_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10192,13 +8378,7 @@ fn c1039_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10526,10 +8706,7 @@ fn c1080_l1092_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10625,10 +8802,7 @@ fn c1092_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10660,10 +8834,7 @@ fn c1096_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10695,13 +8866,7 @@ fn c1100_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10709,13 +8874,7 @@ fn c1101_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10723,13 +8882,7 @@ fn c1102_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10737,13 +8890,7 @@ fn c1103_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10783,10 +8930,7 @@ fn c1108_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10794,10 +8938,7 @@ fn c1109_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -10805,10 +8946,7 @@ fn c1110_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10816,10 +8954,7 @@ fn c1111_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10827,13 +8962,7 @@ fn c1112_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10841,13 +8970,7 @@ fn c1113_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10855,13 +8978,7 @@ fn c1114_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10869,13 +8986,7 @@ fn c1115_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10883,13 +8994,7 @@ fn c1116_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10897,13 +9002,7 @@ fn c1117_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10911,13 +9010,7 @@ fn c1118_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10925,13 +9018,7 @@ fn c1119_l1131_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10939,13 +9026,7 @@ fn c1120_l1132_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10953,13 +9034,7 @@ fn c1121_l1133_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10967,13 +9042,7 @@ fn c1122_l1134_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10981,13 +9050,7 @@ fn c1123_l1135_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -10995,13 +9058,7 @@ fn c1124_l1136_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11009,13 +9066,7 @@ fn c1125_l1137_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11023,13 +9074,7 @@ fn c1126_l1138_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11037,13 +9082,7 @@ fn c1127_l1139_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11179,13 +9218,7 @@ fn c1144_l1156_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11193,13 +9226,7 @@ fn c1145_l1157_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11207,13 +9234,7 @@ fn c1146_l1158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11221,13 +9242,7 @@ fn c1147_l1159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11235,13 +9250,7 @@ fn c1148_l1160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11249,13 +9258,7 @@ fn c1149_l1161_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11263,13 +9266,7 @@ fn c1150_l1162_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11277,13 +9274,7 @@ fn c1151_l1163_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11291,13 +9282,7 @@ fn c1152_l1164_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11305,13 +9290,7 @@ fn c1153_l1165_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11319,13 +9298,7 @@ fn c1154_l1166_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11333,13 +9306,7 @@ fn c1155_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11347,13 +9314,7 @@ fn c1156_l1168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11361,13 +9322,7 @@ fn c1157_l1169_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11375,13 +9330,7 @@ fn c1158_l1170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11389,13 +9338,7 @@ fn c1159_l1171_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11403,13 +9346,7 @@ fn c1160_l1172_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11417,13 +9354,7 @@ fn c1161_l1173_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11431,13 +9362,7 @@ fn c1162_l1174_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11445,13 +9370,7 @@ fn c1163_l1175_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11459,13 +9378,7 @@ fn c1164_l1176_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11473,13 +9386,7 @@ fn c1165_l1177_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11487,13 +9394,7 @@ fn c1166_l1178_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11501,13 +9402,7 @@ fn c1167_l1179_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11579,13 +9474,7 @@ fn c1176_l1188_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11593,13 +9482,7 @@ fn c1177_l1189_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11607,13 +9490,7 @@ fn c1178_l1190_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11621,13 +9498,7 @@ fn c1179_l1191_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11635,13 +9506,7 @@ fn c1180_l1192_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11649,13 +9514,7 @@ fn c1181_l1193_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11663,13 +9522,7 @@ fn c1182_l1194_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11677,13 +9530,7 @@ fn c1183_l1195_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11691,13 +9538,7 @@ fn c1184_l1196_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11705,13 +9546,7 @@ fn c1185_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11719,13 +9554,7 @@ fn c1186_l1198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11733,13 +9562,7 @@ fn c1187_l1199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11747,13 +9570,7 @@ fn c1188_l1200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11761,13 +9578,7 @@ fn c1189_l1201_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11775,13 +9586,7 @@ fn c1190_l1202_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11789,13 +9594,7 @@ fn c1191_l1203_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11803,13 +9602,7 @@ fn c1192_l1204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11817,13 +9610,7 @@ fn c1193_l1205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11831,13 +9618,7 @@ fn c1194_l1206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11845,13 +9626,7 @@ fn c1195_l1207_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11859,13 +9634,7 @@ fn c1196_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11873,13 +9642,7 @@ fn c1197_l1209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11887,13 +9650,7 @@ fn c1198_l1210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -11901,13 +9658,7 @@ fn c1199_l1211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12075,10 +9826,7 @@ fn c1220_l1232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12086,10 +9834,7 @@ fn c1221_l1233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12097,10 +9842,7 @@ fn c1222_l1234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12108,10 +9850,7 @@ fn c1223_l1235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12151,10 +9890,7 @@ fn c1228_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12186,13 +9922,7 @@ fn c1232_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12200,13 +9930,7 @@ fn c1233_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12214,13 +9938,7 @@ fn c1234_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12228,13 +9946,7 @@ fn c1235_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12242,13 +9954,7 @@ fn c1236_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12256,13 +9962,7 @@ fn c1237_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12270,13 +9970,7 @@ fn c1238_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12284,13 +9978,7 @@ fn c1239_l1251_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13098,10 +10786,7 @@ fn c1340_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13109,10 +10794,7 @@ fn c1341_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13120,10 +10802,7 @@ fn c1342_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13131,10 +10810,7 @@ fn c1343_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13174,10 +10850,7 @@ fn c1348_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13209,13 +10882,7 @@ fn c1352_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13223,13 +10890,7 @@ fn c1353_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13237,13 +10898,7 @@ fn c1354_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13251,13 +10906,7 @@ fn c1355_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13265,13 +10914,7 @@ fn c1356_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13279,13 +10922,7 @@ fn c1357_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13293,13 +10930,7 @@ fn c1358_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13307,13 +10938,7 @@ fn c1359_l1371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13481,10 +11106,7 @@ fn c1380_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13492,10 +11114,7 @@ fn c1381_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13503,10 +11122,7 @@ fn c1382_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13514,10 +11130,7 @@ fn c1383_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13557,10 +11170,7 @@ fn c1388_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13592,13 +11202,7 @@ fn c1392_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13606,13 +11210,7 @@ fn c1393_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13620,13 +11218,7 @@ fn c1394_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13634,13 +11226,7 @@ fn c1395_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13648,13 +11234,7 @@ fn c1396_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13662,13 +11242,7 @@ fn c1397_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13676,13 +11250,7 @@ fn c1398_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13690,13 +11258,7 @@ fn c1399_l1411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13704,10 +11266,7 @@ fn c1400_l1412_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13715,10 +11274,7 @@ fn c1401_l1413_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13726,10 +11282,7 @@ fn c1402_l1414_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13737,10 +11290,7 @@ fn c1403_l1415_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13812,10 +11362,7 @@ fn c1412_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13823,10 +11370,7 @@ fn c1413_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13834,10 +11378,7 @@ fn c1414_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13845,10 +11386,7 @@ fn c1415_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13856,10 +11394,7 @@ fn c1416_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13867,10 +11402,7 @@ fn c1417_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13878,10 +11410,7 @@ fn c1418_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13889,10 +11418,7 @@ fn c1419_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13900,13 +11426,7 @@ fn c1420_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13914,13 +11434,7 @@ fn c1421_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13928,13 +11442,7 @@ fn c1422_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13942,13 +11450,7 @@ fn c1423_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13988,13 +11490,7 @@ fn c1428_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14002,13 +11498,7 @@ fn c1429_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14016,13 +11506,7 @@ fn c1430_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14030,13 +11514,7 @@ fn c1431_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14044,13 +11522,7 @@ fn c1432_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14058,13 +11530,7 @@ fn c1433_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14072,13 +11538,7 @@ fn c1434_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14086,13 +11546,7 @@ fn c1435_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14100,13 +11554,7 @@ fn c1436_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14114,13 +11562,7 @@ fn c1437_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14128,13 +11570,7 @@ fn c1438_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14142,13 +11578,7 @@ fn c1439_l1451_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14476,10 +11906,7 @@ fn c1480_l1492_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14575,10 +12002,7 @@ fn c1492_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14610,10 +12034,7 @@ fn c1496_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14645,13 +12066,7 @@ fn c1500_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14659,13 +12074,7 @@ fn c1501_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14673,13 +12082,7 @@ fn c1502_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14687,13 +12090,7 @@ fn c1503_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14733,10 +12130,7 @@ fn c1508_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14744,10 +12138,7 @@ fn c1509_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14755,10 +12146,7 @@ fn c1510_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14766,10 +12154,7 @@ fn c1511_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -14777,13 +12162,7 @@ fn c1512_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14791,13 +12170,7 @@ fn c1513_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14805,13 +12178,7 @@ fn c1514_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14819,13 +12186,7 @@ fn c1515_l1527_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14833,13 +12194,7 @@ fn c1516_l1528_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14847,13 +12202,7 @@ fn c1517_l1529_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14861,13 +12210,7 @@ fn c1518_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14875,13 +12218,7 @@ fn c1519_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14889,13 +12226,7 @@ fn c1520_l1532_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14903,13 +12234,7 @@ fn c1521_l1533_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14917,13 +12242,7 @@ fn c1522_l1534_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14931,13 +12250,7 @@ fn c1523_l1535_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14945,13 +12258,7 @@ fn c1524_l1536_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14959,13 +12266,7 @@ fn c1525_l1537_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14973,13 +12274,7 @@ fn c1526_l1538_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14987,13 +12282,7 @@ fn c1527_l1539_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15129,13 +12418,7 @@ fn c1544_l1556_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15143,13 +12426,7 @@ fn c1545_l1557_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15157,13 +12434,7 @@ fn c1546_l1558_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15171,13 +12442,7 @@ fn c1547_l1559_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15185,13 +12450,7 @@ fn c1548_l1560_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15199,13 +12458,7 @@ fn c1549_l1561_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15213,13 +12466,7 @@ fn c1550_l1562_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15227,13 +12474,7 @@ fn c1551_l1563_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15241,13 +12482,7 @@ fn c1552_l1564_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15255,13 +12490,7 @@ fn c1553_l1565_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15269,13 +12498,7 @@ fn c1554_l1566_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15283,13 +12506,7 @@ fn c1555_l1567_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15297,13 +12514,7 @@ fn c1556_l1568_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15311,13 +12522,7 @@ fn c1557_l1569_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15325,13 +12530,7 @@ fn c1558_l1570_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15339,13 +12538,7 @@ fn c1559_l1571_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15353,13 +12546,7 @@ fn c1560_l1572_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15367,13 +12554,7 @@ fn c1561_l1573_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15381,13 +12562,7 @@ fn c1562_l1574_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15395,13 +12570,7 @@ fn c1563_l1575_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15409,13 +12578,7 @@ fn c1564_l1576_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15423,13 +12586,7 @@ fn c1565_l1577_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15437,13 +12594,7 @@ fn c1566_l1578_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15451,13 +12602,7 @@ fn c1567_l1579_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15529,13 +12674,7 @@ fn c1576_l1588_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15543,13 +12682,7 @@ fn c1577_l1589_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15557,13 +12690,7 @@ fn c1578_l1590_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15571,13 +12698,7 @@ fn c1579_l1591_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15585,13 +12706,7 @@ fn c1580_l1592_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15599,13 +12714,7 @@ fn c1581_l1593_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15613,13 +12722,7 @@ fn c1582_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15627,13 +12730,7 @@ fn c1583_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15641,13 +12738,7 @@ fn c1584_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15655,13 +12746,7 @@ fn c1585_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15669,13 +12754,7 @@ fn c1586_l1598_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15683,13 +12762,7 @@ fn c1587_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15697,13 +12770,7 @@ fn c1588_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15711,13 +12778,7 @@ fn c1589_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15725,13 +12786,7 @@ fn c1590_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15739,13 +12794,7 @@ fn c1591_l1603_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15753,13 +12802,7 @@ fn c1592_l1604_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15767,13 +12810,7 @@ fn c1593_l1605_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15781,13 +12818,7 @@ fn c1594_l1606_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15795,13 +12826,7 @@ fn c1595_l1607_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15809,13 +12834,7 @@ fn c1596_l1608_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15823,13 +12842,7 @@ fn c1597_l1609_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15837,13 +12850,7 @@ fn c1598_l1610_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -15851,13 +12858,7 @@ fn c1599_l1611_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16025,10 +13026,7 @@ fn c1620_l1632_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16036,10 +13034,7 @@ fn c1621_l1633_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16047,10 +13042,7 @@ fn c1622_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16058,10 +13050,7 @@ fn c1623_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16101,10 +13090,7 @@ fn c1628_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -16136,13 +13122,7 @@ fn c1632_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16150,13 +13130,7 @@ fn c1633_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16164,13 +13138,7 @@ fn c1634_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16178,13 +13146,7 @@ fn c1635_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16192,13 +13154,7 @@ fn c1636_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16206,13 +13162,7 @@ fn c1637_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16220,13 +13170,7 @@ fn c1638_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -16234,13 +13178,7 @@ fn c1639_l1651_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17048,10 +13986,7 @@ fn c1740_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17059,10 +13994,7 @@ fn c1741_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17070,10 +14002,7 @@ fn c1742_l1754_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17081,10 +14010,7 @@ fn c1743_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17124,10 +14050,7 @@ fn c1748_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17159,13 +14082,7 @@ fn c1752_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17173,13 +14090,7 @@ fn c1753_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17187,13 +14098,7 @@ fn c1754_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17201,13 +14106,7 @@ fn c1755_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17215,13 +14114,7 @@ fn c1756_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17229,13 +14122,7 @@ fn c1757_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17243,13 +14130,7 @@ fn c1758_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17257,13 +14138,7 @@ fn c1759_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17431,10 +14306,7 @@ fn c1780_l1792_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17442,10 +14314,7 @@ fn c1781_l1793_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17453,10 +14322,7 @@ fn c1782_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17464,10 +14330,7 @@ fn c1783_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17507,10 +14370,7 @@ fn c1788_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17542,13 +14402,7 @@ fn c1792_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17556,13 +14410,7 @@ fn c1793_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17570,13 +14418,7 @@ fn c1794_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17584,13 +14426,7 @@ fn c1795_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17598,13 +14434,7 @@ fn c1796_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17612,13 +14442,7 @@ fn c1797_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17626,13 +14450,7 @@ fn c1798_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17640,13 +14458,7 @@ fn c1799_l1811_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17654,10 +14466,7 @@ fn c1800_l1812_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17665,10 +14474,7 @@ fn c1801_l1813_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17676,10 +14482,7 @@ fn c1802_l1814_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17687,10 +14490,7 @@ fn c1803_l1815_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17762,10 +14562,7 @@ fn c1812_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17773,10 +14570,7 @@ fn c1813_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17784,10 +14578,7 @@ fn c1814_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17795,10 +14586,7 @@ fn c1815_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17806,10 +14594,7 @@ fn c1816_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17817,10 +14602,7 @@ fn c1817_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17828,10 +14610,7 @@ fn c1818_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17839,10 +14618,7 @@ fn c1819_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17850,13 +14626,7 @@ fn c1820_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17864,13 +14634,7 @@ fn c1821_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17878,13 +14642,7 @@ fn c1822_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17892,13 +14650,7 @@ fn c1823_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17938,13 +14690,7 @@ fn c1828_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17952,13 +14698,7 @@ fn c1829_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17966,13 +14706,7 @@ fn c1830_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -17980,13 +14714,7 @@ fn c1831_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -17994,13 +14722,7 @@ fn c1832_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18008,13 +14730,7 @@ fn c1833_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18022,13 +14738,7 @@ fn c1834_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18036,13 +14746,7 @@ fn c1835_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18050,13 +14754,7 @@ fn c1836_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18064,13 +14762,7 @@ fn c1837_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18078,13 +14770,7 @@ fn c1838_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18092,13 +14778,7 @@ fn c1839_l1851_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18426,10 +15106,7 @@ fn c1880_l1892_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18525,10 +15202,7 @@ fn c1892_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18560,10 +15234,7 @@ fn c1896_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18595,13 +15266,7 @@ fn c1900_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18609,13 +15274,7 @@ fn c1901_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18623,13 +15282,7 @@ fn c1902_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18637,13 +15290,7 @@ fn c1903_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18683,10 +15330,7 @@ fn c1908_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18694,10 +15338,7 @@ fn c1909_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18705,10 +15346,7 @@ fn c1910_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -18716,10 +15354,7 @@ fn c1911_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18727,13 +15362,7 @@ fn c1912_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18741,13 +15370,7 @@ fn c1913_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18755,13 +15378,7 @@ fn c1914_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18769,13 +15386,7 @@ fn c1915_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18783,13 +15394,7 @@ fn c1916_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18797,13 +15402,7 @@ fn c1917_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18811,13 +15410,7 @@ fn c1918_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18825,13 +15418,7 @@ fn c1919_l1931_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18839,13 +15426,7 @@ fn c1920_l1932_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18853,13 +15434,7 @@ fn c1921_l1933_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18867,13 +15442,7 @@ fn c1922_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18881,13 +15450,7 @@ fn c1923_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18895,13 +15458,7 @@ fn c1924_l1936_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18909,13 +15466,7 @@ fn c1925_l1937_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18923,13 +15474,7 @@ fn c1926_l1938_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -18937,13 +15482,7 @@ fn c1927_l1939_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19079,13 +15618,7 @@ fn c1944_l1956_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19093,13 +15626,7 @@ fn c1945_l1957_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19107,13 +15634,7 @@ fn c1946_l1958_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19121,13 +15642,7 @@ fn c1947_l1959_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19135,13 +15650,7 @@ fn c1948_l1960_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19149,13 +15658,7 @@ fn c1949_l1961_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19163,13 +15666,7 @@ fn c1950_l1962_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19177,13 +15674,7 @@ fn c1951_l1963_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19191,13 +15682,7 @@ fn c1952_l1964_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19205,13 +15690,7 @@ fn c1953_l1965_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19219,13 +15698,7 @@ fn c1954_l1966_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19233,13 +15706,7 @@ fn c1955_l1967_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19247,13 +15714,7 @@ fn c1956_l1968_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19261,13 +15722,7 @@ fn c1957_l1969_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19275,13 +15730,7 @@ fn c1958_l1970_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19289,13 +15738,7 @@ fn c1959_l1971_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19303,13 +15746,7 @@ fn c1960_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19317,13 +15754,7 @@ fn c1961_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19331,13 +15762,7 @@ fn c1962_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19345,13 +15770,7 @@ fn c1963_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19359,13 +15778,7 @@ fn c1964_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19373,13 +15786,7 @@ fn c1965_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19387,13 +15794,7 @@ fn c1966_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19401,13 +15802,7 @@ fn c1967_l1979_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19479,13 +15874,7 @@ fn c1976_l1988_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19493,13 +15882,7 @@ fn c1977_l1989_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19507,13 +15890,7 @@ fn c1978_l1990_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19521,13 +15898,7 @@ fn c1979_l1991_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19535,13 +15906,7 @@ fn c1980_l1992_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19549,13 +15914,7 @@ fn c1981_l1993_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19563,13 +15922,7 @@ fn c1982_l1994_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19577,13 +15930,7 @@ fn c1983_l1995_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19591,13 +15938,7 @@ fn c1984_l1996_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19605,13 +15946,7 @@ fn c1985_l1997_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19619,13 +15954,7 @@ fn c1986_l1998_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19633,13 +15962,7 @@ fn c1987_l1999_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19647,13 +15970,7 @@ fn c1988_l2000_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19661,13 +15978,7 @@ fn c1989_l2001_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19675,13 +15986,7 @@ fn c1990_l2002_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19689,13 +15994,7 @@ fn c1991_l2003_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19703,13 +16002,7 @@ fn c1992_l2004_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19717,13 +16010,7 @@ fn c1993_l2005_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19731,13 +16018,7 @@ fn c1994_l2006_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19745,13 +16026,7 @@ fn c1995_l2007_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19759,13 +16034,7 @@ fn c1996_l2008_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19773,13 +16042,7 @@ fn c1997_l2009_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19787,13 +16050,7 @@ fn c1998_l2010_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19801,13 +16058,7 @@ fn c1999_l2011_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19975,10 +16226,7 @@ fn c2020_l2032_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -19986,10 +16234,7 @@ fn c2021_l2033_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -19997,10 +16242,7 @@ fn c2022_l2034_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20008,10 +16250,7 @@ fn c2023_l2035_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20051,10 +16290,7 @@ fn c2028_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -20086,13 +16322,7 @@ fn c2032_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20100,13 +16330,7 @@ fn c2033_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20114,13 +16338,7 @@ fn c2034_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20128,13 +16346,7 @@ fn c2035_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20142,13 +16354,7 @@ fn c2036_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20156,13 +16362,7 @@ fn c2037_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20170,13 +16370,7 @@ fn c2038_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20184,13 +16378,7 @@ fn c2039_l2051_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -20998,10 +17186,7 @@ fn c2140_l2152_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21009,10 +17194,7 @@ fn c2141_l2153_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21020,10 +17202,7 @@ fn c2142_l2154_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21031,10 +17210,7 @@ fn c2143_l2155_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21074,10 +17250,7 @@ fn c2148_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21109,13 +17282,7 @@ fn c2152_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21123,13 +17290,7 @@ fn c2153_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21137,13 +17298,7 @@ fn c2154_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21151,13 +17306,7 @@ fn c2155_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21165,13 +17314,7 @@ fn c2156_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21179,13 +17322,7 @@ fn c2157_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21193,13 +17330,7 @@ fn c2158_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21207,13 +17338,7 @@ fn c2159_l2171_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21381,10 +17506,7 @@ fn c2180_l2192_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21392,10 +17514,7 @@ fn c2181_l2193_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21403,10 +17522,7 @@ fn c2182_l2194_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21414,10 +17530,7 @@ fn c2183_l2195_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((6.283185307179586f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21457,10 +17570,7 @@ fn c2188_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21492,13 +17602,7 @@ fn c2192_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21506,13 +17610,7 @@ fn c2193_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21520,13 +17618,7 @@ fn c2194_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21534,13 +17626,7 @@ fn c2195_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21548,13 +17634,7 @@ fn c2196_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21562,13 +17642,7 @@ fn c2197_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21576,13 +17650,7 @@ fn c2198_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21590,13 +17658,7 @@ fn c2199_l2211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21604,10 +17666,7 @@ fn c2200_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21615,10 +17674,7 @@ fn c2201_l2213_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21626,10 +17682,7 @@ fn c2202_l2214_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21637,10 +17690,7 @@ fn c2203_l2215_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21712,10 +17762,7 @@ fn c2212_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21723,10 +17770,7 @@ fn c2213_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21734,10 +17778,7 @@ fn c2214_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21745,10 +17786,7 @@ fn c2215_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21756,10 +17794,7 @@ fn c2216_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21767,10 +17802,7 @@ fn c2217_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21778,10 +17810,7 @@ fn c2218_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21789,10 +17818,7 @@ fn c2219_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21800,13 +17826,7 @@ fn c2220_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21814,13 +17834,7 @@ fn c2221_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21828,13 +17842,7 @@ fn c2222_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21842,13 +17850,7 @@ fn c2223_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21888,13 +17890,7 @@ fn c2228_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21902,13 +17898,7 @@ fn c2229_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21916,13 +17906,7 @@ fn c2230_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -21930,13 +17914,7 @@ fn c2231_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21944,13 +17922,7 @@ fn c2232_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21958,13 +17930,7 @@ fn c2233_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21972,13 +17938,7 @@ fn c2234_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -21986,13 +17946,7 @@ fn c2235_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22000,13 +17954,7 @@ fn c2236_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22014,13 +17962,7 @@ fn c2237_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22028,13 +17970,7 @@ fn c2238_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22042,13 +17978,7 @@ fn c2239_l2251_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22376,10 +18306,7 @@ fn c2280_l2292_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22475,10 +18402,7 @@ fn c2292_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-0.5f64))],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22510,10 +18434,7 @@ fn c2296_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22545,13 +18466,7 @@ fn c2300_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22559,13 +18474,7 @@ fn c2301_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22573,13 +18482,7 @@ fn c2302_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22587,13 +18490,7 @@ fn c2303_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22633,10 +18530,7 @@ fn c2308_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22644,10 +18538,7 @@ fn c2309_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22655,10 +18546,7 @@ fn c2310_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::NEG_INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22666,10 +18554,7 @@ fn c2311_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64(f64::INFINITY)],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -22677,13 +18562,7 @@ fn c2312_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22691,13 +18570,7 @@ fn c2313_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22705,13 +18578,7 @@ fn c2314_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22719,13 +18586,7 @@ fn c2315_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22733,13 +18594,7 @@ fn c2316_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22747,13 +18602,7 @@ fn c2317_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22761,13 +18610,7 @@ fn c2318_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22775,13 +18618,7 @@ fn c2319_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22789,13 +18626,7 @@ fn c2320_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22803,13 +18634,7 @@ fn c2321_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22817,13 +18642,7 @@ fn c2322_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22831,13 +18650,7 @@ fn c2323_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22845,13 +18658,7 @@ fn c2324_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22859,13 +18666,7 @@ fn c2325_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22873,13 +18674,7 @@ fn c2326_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -22887,13 +18682,7 @@ fn c2327_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23029,13 +18818,7 @@ fn c2344_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23043,13 +18826,7 @@ fn c2345_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23057,13 +18834,7 @@ fn c2346_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23071,13 +18842,7 @@ fn c2347_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23085,13 +18850,7 @@ fn c2348_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23099,13 +18858,7 @@ fn c2349_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.5f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23113,13 +18866,7 @@ fn c2350_l2362_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23127,13 +18874,7 @@ fn c2351_l2363_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.5f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23141,13 +18882,7 @@ fn c2352_l2364_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23155,13 +18890,7 @@ fn c2353_l2365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23169,13 +18898,7 @@ fn c2354_l2366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23183,13 +18906,7 @@ fn c2355_l2367_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23197,13 +18914,7 @@ fn c2356_l2368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23211,13 +18922,7 @@ fn c2357_l2369_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23225,13 +18930,7 @@ fn c2358_l2370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23239,13 +18938,7 @@ fn c2359_l2371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23253,13 +18946,7 @@ fn c2360_l2372_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23267,13 +18954,7 @@ fn c2361_l2373_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23281,13 +18962,7 @@ fn c2362_l2374_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23295,13 +18970,7 @@ fn c2363_l2375_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23309,13 +18978,7 @@ fn c2364_l2376_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23323,13 +18986,7 @@ fn c2365_l2377_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23337,13 +18994,7 @@ fn c2366_l2378_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23351,13 +19002,7 @@ fn c2367_l2379_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((6.283185307179586f64)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23429,13 +19074,7 @@ fn c2376_l2388_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23443,13 +19082,7 @@ fn c2377_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23457,13 +19090,7 @@ fn c2378_l2390_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23471,13 +19098,7 @@ fn c2379_l2391_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23485,13 +19106,7 @@ fn c2380_l2392_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23499,13 +19114,7 @@ fn c2381_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::NEG_INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23513,13 +19122,7 @@ fn c2382_l2394_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23527,13 +19130,7 @@ fn c2383_l2395_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23541,13 +19138,7 @@ fn c2384_l2396_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23555,13 +19146,7 @@ fn c2385_l2397_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23569,13 +19154,7 @@ fn c2386_l2398_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23583,13 +19162,7 @@ fn c2387_l2399_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23597,13 +19170,7 @@ fn c2388_l2400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23611,13 +19178,7 @@ fn c2389_l2401_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23625,13 +19186,7 @@ fn c2390_l2402_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23639,13 +19194,7 @@ fn c2391_l2403_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23653,13 +19202,7 @@ fn c2392_l2404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23667,13 +19210,7 @@ fn c2393_l2405_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23681,13 +19218,7 @@ fn c2394_l2406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23695,13 +19226,7 @@ fn c2395_l2407_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(18443366373989023744)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23709,13 +19234,7 @@ fn c2396_l2408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23723,13 +19242,7 @@ fn c2397_l2409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23737,13 +19250,7 @@ fn c2398_l2410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -23751,13 +19258,7 @@ fn c2399_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9219994337134247936)),
-        ],
-    );
+    let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
diff --git a/lib/runtime/tests/spectests/fac.rs b/lib/runtime/tests/spectests/fac.rs
index 89b1b6430..583f5967f 100644
--- a/lib/runtime/tests/spectests/fac.rs
+++ b/lib/runtime/tests/spectests/fac.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i64) (result i64)))
       (func (;0;) (type 0) (param i64) (result i64)
@@ -132,11 +136,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
diff --git a/lib/runtime/tests/spectests/float_exprs.rs b/lib/runtime/tests/spectests/float_exprs.rs
index d292717d8..33a6b0b23 100644
--- a/lib/runtime/tests/spectests/float_exprs.rs
+++ b/lib/runtime/tests/spectests/float_exprs.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 6
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64 f64 f64) (result f64)))
       (func (;0;) (type 0) (param f64 f64 f64) (result f64)
@@ -27,11 +31,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -59,10 +60,7 @@ fn c2_l12_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((52699336439236750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((0.00000000000000000000000000000006654454781339856f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000000000015872537009936566f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000015872537009936566f64)))));
     result.map(|_| ())
 }
 
@@ -70,12 +68,7 @@ fn c3_l13_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.0000000000000000000000000000007262766035707377f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000004619684894228461f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.00000000000000000000000000000000000000000000000000228152068276836f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000228152068276836f64)))));
     result.map(|_| ())
 }
 
@@ -100,7 +93,7 @@ fn test_module_1() {
     c4_l14_action_invoke(&mut instance);
     c5_l15_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -120,11 +113,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -135,50 +125,23 @@ fn start_module_2(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.00000021584361f32)),
-            Value::F32((259340640000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((266934960000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_fma", &[Value::F32((35184304000000000000000000000000000000.0f32)), Value::F32((0.00000021584361f32)), Value::F32((259340640000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((266934960000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000001225534f32)),
-            Value::F32((0.0000000000000000000000000041316436f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.0000000000000000000000087894724f32))))
-    );
+    let result = instance.call("f32.no_fma", &[Value::F32((0.0000000071753243f32)), Value::F32((-0.000000000000001225534f32)), Value::F32((0.0000000000000000000000000041316436f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000087894724f32)))));
     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)),
-            Value::F32((0.00020773262f32)),
-            Value::F32((1797.6421f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fma", &[Value::F32((231063440000.0f32)), Value::F32((0.00020773262f32)), Value::F32((1797.6421f32))]);
     assert_eq!(result, Ok(Some(Value::F32((48001210.0f32)))));
     result.map(|_| ())
 }
@@ -186,14 +149,7 @@ fn c9_l28_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-7265493.5f32)),
-            Value::F32((-2.3964283f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fma", &[Value::F32((0.0045542703f32)), Value::F32((-7265493.5f32)), Value::F32((-2.3964283f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-33091.414f32)))));
     result.map(|_| ())
 }
@@ -201,14 +157,7 @@ fn c10_l29_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0000000000000000000008570631f32)),
-            Value::F32((-21579143000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fma", &[Value::F32((98881730000000000000000000000000000000.0f32)), Value::F32((-0.0000000000000000000008570631f32)), Value::F32((-21579143000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-84747910000000000.0f32)))));
     result.map(|_| ())
 }
@@ -271,7 +220,7 @@ fn test_module_2() {
     c15_l34_action_invoke(&mut instance);
     c16_l35_action_invoke(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -287,11 +236,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -317,41 +263,23 @@ fn c19_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c20_l49_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c20_l49_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_add_zero", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c20_l49_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c21_l50_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c21_l50_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_add_zero", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c21_l50_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -367,7 +295,7 @@ fn test_module_3() {
     c20_l49_assert_return_arithmetic_nan(&mut instance);
     c21_l50_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -383,11 +311,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -413,41 +338,23 @@ fn c24_l62_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c25_l63_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c25_l63_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_zero_sub", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c25_l63_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c26_l64_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c26_l64_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_zero_sub", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c26_l64_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -463,7 +370,7 @@ fn test_module_4() {
     c25_l63_assert_return_arithmetic_nan(&mut instance);
     c26_l64_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -479,11 +386,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -493,41 +397,23 @@ fn start_module_5(instance: &mut Instance) {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c28_l75_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c28_l75_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_sub_zero", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c28_l75_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c29_l76_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c29_l76_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_sub_zero", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c29_l76_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -541,7 +427,7 @@ fn test_module_5() {
     c28_l75_assert_return_arithmetic_nan(&mut instance);
     c29_l76_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -557,11 +443,8 @@ fn create_module_6() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -595,21 +478,12 @@ fn c33_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c34_l90_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c34_l90_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_mul_zero", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c34_l90_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -639,21 +513,12 @@ fn c37_l93_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c38_l94_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c38_l94_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_mul_zero", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c38_l94_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -673,7 +538,7 @@ fn test_module_6() {
     c37_l93_action_invoke(&mut instance);
     c38_l94_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -689,11 +554,8 @@ fn create_module_7() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -703,41 +565,23 @@ fn start_module_7(instance: &mut Instance) {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c40_l106_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c40_l106_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_mul_one", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c40_l106_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c41_l107_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c41_l107_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_mul_one", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c41_l107_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -751,7 +595,7 @@ fn test_module_7() {
     c40_l106_assert_return_arithmetic_nan(&mut instance);
     c41_l107_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_8() -> Box<Instance> {
+fn create_module_8() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -767,11 +611,8 @@ fn create_module_8() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_8(instance: &mut Instance) {
@@ -781,149 +622,89 @@ fn start_module_8(instance: &mut Instance) {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c43_l118_assert_return_canonical_nan");
+    println!("Executing function {}", "c43_l118_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_zero_div", &[Value::F32((0.0f32))]).unwrap().expect("Missing result in c43_l118_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c44_l119_assert_return_canonical_nan");
+    println!("Executing function {}", "c44_l119_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_zero_div", &[Value::F32((-0.0f32))]).unwrap().expect("Missing result in c44_l119_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c45_l120_assert_return_canonical_nan");
+    println!("Executing function {}", "c45_l120_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_zero_div", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c45_l120_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c46_l121_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c46_l121_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_zero_div", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c46_l121_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c47_l122_assert_return_canonical_nan");
+    println!("Executing function {}", "c47_l122_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_zero_div", &[Value::F64((0.0f64))]).unwrap().expect("Missing result in c47_l122_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c48_l123_assert_return_canonical_nan");
+    println!("Executing function {}", "c48_l123_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_zero_div", &[Value::F64((-0.0f64))]).unwrap().expect("Missing result in c48_l123_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c49_l124_assert_return_canonical_nan");
+    println!("Executing function {}", "c49_l124_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_zero_div", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c49_l124_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c50_l125_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c50_l125_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_zero_div", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c50_l125_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -943,7 +724,7 @@ fn test_module_8() {
     c49_l124_assert_return_canonical_nan(&mut instance);
     c50_l125_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_9() -> Box<Instance> {
+fn create_module_9() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -959,11 +740,8 @@ fn create_module_9() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_9(instance: &mut Instance) {
@@ -973,41 +751,23 @@ fn start_module_9(instance: &mut Instance) {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c52_l136_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c52_l136_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_div_one", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c52_l136_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c53_l137_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c53_l137_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_div_one", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c53_l137_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1021,7 +781,7 @@ fn test_module_9() {
     c52_l136_assert_return_arithmetic_nan(&mut instance);
     c53_l137_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_10() -> Box<Instance> {
+fn create_module_10() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -1037,11 +797,8 @@ fn create_module_10() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_10(instance: &mut Instance) {
@@ -1051,41 +808,23 @@ fn start_module_10(instance: &mut Instance) {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c55_l148_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c55_l148_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_div_neg1", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c55_l148_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c56_l149_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c56_l149_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_div_neg1", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c56_l149_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1099,7 +838,7 @@ fn test_module_10() {
     c55_l148_assert_return_arithmetic_nan(&mut instance);
     c56_l149_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_11() -> Box<Instance> {
+fn create_module_11() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -1115,11 +854,8 @@ fn create_module_11() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_11(instance: &mut Instance) {
@@ -1129,41 +865,23 @@ fn start_module_11(instance: &mut Instance) {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c58_l160_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c58_l160_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_neg0_sub", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c58_l160_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c59_l161_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c59_l161_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_neg0_sub", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c59_l161_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1177,7 +895,7 @@ fn test_module_11() {
     c58_l160_assert_return_arithmetic_nan(&mut instance);
     c59_l161_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_12() -> Box<Instance> {
+fn create_module_12() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -1193,11 +911,8 @@ fn create_module_12() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_12(instance: &mut Instance) {
@@ -1207,41 +922,23 @@ fn start_module_12(instance: &mut Instance) {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c61_l172_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c61_l172_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_neg1_mul", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c61_l172_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c62_l173_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c62_l173_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_neg1_mul", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c62_l173_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1255,7 +952,7 @@ fn test_module_12() {
     c61_l172_assert_return_arithmetic_nan(&mut instance);
     c62_l173_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_13() -> Box<Instance> {
+fn create_module_13() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result i32)))
       (type (;1;) (func (param f64) (result i32)))
@@ -1271,11 +968,8 @@ fn create_module_13() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_13(instance: &mut Instance) {
@@ -1286,10 +980,7 @@ fn start_module_13(instance: &mut Instance) {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_eq_self", &[Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1297,10 +988,7 @@ fn c64_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_eq_self", &[Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -1315,7 +1003,7 @@ fn test_module_13() {
     c64_l184_action_invoke(&mut instance);
     c65_l185_action_invoke(&mut instance);
 }
-fn create_module_14() -> Box<Instance> {
+fn create_module_14() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result i32)))
       (type (;1;) (func (param f64) (result i32)))
@@ -1331,11 +1019,8 @@ fn create_module_14() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_14(instance: &mut Instance) {
@@ -1346,10 +1031,7 @@ fn start_module_14(instance: &mut Instance) {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_ne_self", &[Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -1357,10 +1039,7 @@ fn c67_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_ne_self", &[Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -1375,7 +1054,7 @@ fn test_module_14() {
     c67_l196_action_invoke(&mut instance);
     c68_l197_action_invoke(&mut instance);
 }
-fn create_module_15() -> Box<Instance> {
+fn create_module_15() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -1391,11 +1070,8 @@ fn create_module_15() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_15(instance: &mut Instance) {
@@ -1405,75 +1081,45 @@ fn start_module_15(instance: &mut Instance) {
 
 // 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)])
-        .unwrap()
-        .expect("Missing result in c70_l208_assert_return_canonical_nan");
+    println!("Executing function {}", "c70_l208_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_sub_self", &[Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c70_l208_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c71_l209_assert_return_canonical_nan");
+    println!("Executing function {}", "c71_l209_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_sub_self", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c71_l209_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)])
-        .unwrap()
-        .expect("Missing result in c72_l210_assert_return_canonical_nan");
+    println!("Executing function {}", "c72_l210_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_sub_self", &[Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c72_l210_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c73_l211_assert_return_canonical_nan");
+    println!("Executing function {}", "c73_l211_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_sub_self", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c73_l211_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1489,7 +1135,7 @@ fn test_module_15() {
     c72_l210_assert_return_canonical_nan(&mut instance);
     c73_l211_assert_return_canonical_nan(&mut instance);
 }
-fn create_module_16() -> Box<Instance> {
+fn create_module_16() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -1505,11 +1151,8 @@ fn create_module_16() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_16(instance: &mut Instance) {
@@ -1519,143 +1162,89 @@ fn start_module_16(instance: &mut Instance) {
 
 // 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)])
-        .unwrap()
-        .expect("Missing result in c75_l222_assert_return_canonical_nan");
+    println!("Executing function {}", "c75_l222_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_self", &[Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c75_l222_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c76_l223_assert_return_canonical_nan");
+    println!("Executing function {}", "c76_l223_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_self", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c76_l223_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c77_l224_assert_return_canonical_nan");
+    println!("Executing function {}", "c77_l224_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_self", &[Value::F32((0.0f32))]).unwrap().expect("Missing result in c77_l224_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c78_l225_assert_return_canonical_nan");
+    println!("Executing function {}", "c78_l225_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_self", &[Value::F32((-0.0f32))]).unwrap().expect("Missing result in c78_l225_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)])
-        .unwrap()
-        .expect("Missing result in c79_l226_assert_return_canonical_nan");
+    println!("Executing function {}", "c79_l226_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_self", &[Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c79_l226_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c80_l227_assert_return_canonical_nan");
+    println!("Executing function {}", "c80_l227_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_self", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c80_l227_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c81_l228_assert_return_canonical_nan");
+    println!("Executing function {}", "c81_l228_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_self", &[Value::F64((0.0f64))]).unwrap().expect("Missing result in c81_l228_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c82_l229_assert_return_canonical_nan");
+    println!("Executing function {}", "c82_l229_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_self", &[Value::F64((-0.0f64))]).unwrap().expect("Missing result in c82_l229_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -1675,7 +1264,7 @@ fn test_module_16() {
     c81_l228_assert_return_canonical_nan(&mut instance);
     c82_l229_assert_return_canonical_nan(&mut instance);
 }
-fn create_module_17() -> Box<Instance> {
+fn create_module_17() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -1691,11 +1280,8 @@ fn create_module_17() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_17(instance: &mut Instance) {
@@ -1714,60 +1300,32 @@ fn c84_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-6245626600000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_fold_div_3", &[Value::F32((-18736880000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-6245626600000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.000000000000000000000000040150435f32))))
-    );
+    let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.00000000000000000000000012045131f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000040150435f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000017604486f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.00000000000000000000000000000000000005281346f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000017604486f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.000000000000000008498521f32))))
-    );
+    let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.000000000000000025495563f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000008498521f32)))));
     result.map(|_| ())
 }
 
@@ -1782,18 +1340,8 @@ fn c89_l245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.000000000000000000000000000000000000000000000000003097050307149924f64)
-        )))
-    );
+    let result = instance.call("f64.no_fold_div_3", &[Value::F64((-0.000000000000000000000000000000000000000000000000009291150921449772f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000003097050307149924f64)))));
     result.map(|_| ())
 }
 
@@ -1839,7 +1387,7 @@ fn test_module_17() {
     c92_l248_action_invoke(&mut instance);
     c93_l249_action_invoke(&mut instance);
 }
-fn create_module_18() -> Box<Instance> {
+fn create_module_18() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -1863,11 +1411,8 @@ fn create_module_18() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_18(instance: &mut Instance) {
@@ -1878,32 +1423,15 @@ fn start_module_18(instance: &mut Instance) {
 // 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)),
-            Value::F32((-853617640000000.0f32)),
-            Value::F32((1113849300000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-952399900000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_factor", &[Value::F32((-1435111700000.0f32)), Value::F32((-853617640000000.0f32)), Value::F32((1113849300000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-952399900000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.048412822f32)),
-            Value::F32((-0.002813697f32)),
-        ],
-    );
+    let result = instance.call("f32.no_factor", &[Value::F32((-0.026666632f32)), Value::F32((0.048412822f32)), Value::F32((-0.002813697f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000611872f32)))));
     result.map(|_| ())
 }
@@ -1911,32 +1439,15 @@ fn c96_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00000000000000000010478377f32)),
-            Value::F32((14469202000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-6745508000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_factor", &[Value::F32((-0.00000000000046619777f32)), Value::F32((0.00000000000000000010478377f32)), Value::F32((14469202000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-6745508000000000000000000.0f32)))));
     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)),
-            Value::F32((0.00000000000000000000000010694433f32)),
-            Value::F32((568307000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_factor", &[Value::F32((-0.00000000000000000010689046f32)), Value::F32((0.00000000000000000000000010694433f32)), Value::F32((568307000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-60746540000000000.0f32)))));
     result.map(|_| ())
 }
@@ -1944,14 +1455,7 @@ fn c98_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000007524625f32)),
-            Value::F32((1626770.3f32)),
-        ],
-    );
+    let result = instance.call("f32.no_factor", &[Value::F32((-0.000000000000000000000000063545994f32)), Value::F32((0.0000000000000000000007524625f32)), Value::F32((1626770.3f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0000000000000012239803f32)))));
     result.map(|_| ())
 }
@@ -1976,12 +1480,7 @@ fn c101_l266_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000002146156743463356f64)), Value::F64((-2510967223130241600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (538892923853642600000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((538892923853642600000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -1997,12 +1496,7 @@ fn c103_l268_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000883589921438065f64)), Value::F64((-1735830019469195800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.0000000000000000000000000015337619131701908f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000015337619131701908f64)))));
     result.map(|_| ())
 }
 
@@ -2024,7 +1518,7 @@ fn test_module_18() {
     c103_l268_action_invoke(&mut instance);
     c104_l269_action_invoke(&mut instance);
 }
-fn create_module_19() -> Box<Instance> {
+fn create_module_19() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -2044,11 +1538,8 @@ fn create_module_19() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_19(instance: &mut Instance) {
@@ -2059,32 +1550,15 @@ fn start_module_19(instance: &mut Instance) {
 // 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)),
-            Value::F32((-853617640000000.0f32)),
-            Value::F32((1113849300000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-952400000000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_distribute", &[Value::F32((-1435111700000.0f32)), Value::F32((-853617640000000.0f32)), Value::F32((1113849300000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-952400000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.048412822f32)),
-            Value::F32((-0.002813697f32)),
-        ],
-    );
+    let result = instance.call("f32.no_distribute", &[Value::F32((-0.026666632f32)), Value::F32((0.048412822f32)), Value::F32((-0.002813697f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.000061187195f32)))));
     result.map(|_| ())
 }
@@ -2092,32 +1566,15 @@ fn c107_l281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00000000000000000010478377f32)),
-            Value::F32((14469202000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-6745508500000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_distribute", &[Value::F32((-0.00000000000046619777f32)), Value::F32((0.00000000000000000010478377f32)), Value::F32((14469202000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-6745508500000000000000000.0f32)))));
     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)),
-            Value::F32((0.00000000000000000000000010694433f32)),
-            Value::F32((568307000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_distribute", &[Value::F32((-0.00000000000000000010689046f32)), Value::F32((0.00000000000000000000000010694433f32)), Value::F32((568307000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-60746536000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2125,14 +1582,7 @@ fn c109_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000007524625f32)),
-            Value::F32((1626770.3f32)),
-        ],
-    );
+    let result = instance.call("f32.no_distribute", &[Value::F32((-0.000000000000000000000000063545994f32)), Value::F32((0.0000000000000000000007524625f32)), Value::F32((1626770.3f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0000000000000012239802f32)))));
     result.map(|_| ())
 }
@@ -2157,12 +1607,7 @@ fn c112_l286_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000002146156743463356f64)), Value::F64((-2510967223130241600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (538892923853642500000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((538892923853642500000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -2178,12 +1623,7 @@ fn c114_l288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000883589921438065f64)), Value::F64((-1735830019469195800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.0000000000000000000000000015337619131701907f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000015337619131701907f64)))));
     result.map(|_| ())
 }
 
@@ -2205,7 +1645,7 @@ fn test_module_19() {
     c114_l288_action_invoke(&mut instance);
     c115_l289_action_invoke(&mut instance);
 }
-fn create_module_20() -> Box<Instance> {
+fn create_module_20() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -2225,11 +1665,8 @@ fn create_module_20() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_20(instance: &mut Instance) {
@@ -2240,32 +1677,15 @@ fn start_module_20(instance: &mut Instance) {
 // 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)),
-            Value::F32((-0.00000000000000000007270787f32)),
-            Value::F32((0.000000000000000000000000000000000016406605f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.00000000000000000012547468f32))))
-    );
+    let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-0.00000000000000000000000000000000002831349f32)), Value::F32((-0.00000000000000000007270787f32)), Value::F32((0.000000000000000000000000000000000016406605f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000012547468f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000040864003f32)),
-            Value::F32((-9245928300000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-3145897700000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000040864003f32)), Value::F32((-9245928300000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -2273,52 +1693,23 @@ fn c118_l301_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.00000081292654f32)),
-            Value::F32((-0.00000000000000000000000000000000000015469397f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-489548120000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-93157.43f32)), Value::F32((-0.00000081292654f32)), Value::F32((-0.00000000000000000000000000000000000015469397f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-489548120000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((17887725000000000000000.0f32)),
-            Value::F32((514680230000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.000000000000000000000000003093073f32))))
-    );
+    let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-0.00000000000000000000000000008899643f32)), Value::F32((17887725000000000000000.0f32)), Value::F32((514680230000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000003093073f32)))));
     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)),
-            Value::F32((33330492.0f32)),
-            Value::F32((-3253108800000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((9222036000000000000000000000000000.0f32)), Value::F32((33330492.0f32)), Value::F32((-3253108800000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-94486550000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2327,10 +1718,7 @@ fn c121_l304_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.0000000000000000000000000000000000018313439132919336f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009543270551003098f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-1093596114413331000000000000000.0f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-1093596114413331000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -2354,12 +1742,7 @@ fn c124_l307_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-12087878984017852000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-596613380626062300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-91013507803376260000000000000000000000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-91013507803376260000000000000000000000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -2389,7 +1772,7 @@ fn test_module_20() {
     c125_l308_action_invoke(&mut instance);
     c126_l309_action_invoke(&mut instance);
 }
-fn create_module_21() -> Box<Instance> {
+fn create_module_21() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -2409,11 +1792,8 @@ fn create_module_21() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_21(instance: &mut Instance) {
@@ -2424,14 +1804,7 @@ fn start_module_21(instance: &mut Instance) {
 // 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)),
-            Value::F32((-0.00000000000000000007270787f32)),
-            Value::F32((0.000000000000000000000000000000000016406605f32)),
-        ],
-    );
+    let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-0.00000000000000000000000000000000002831349f32)), Value::F32((-0.00000000000000000007270787f32)), Value::F32((0.000000000000000000000000000000000016406605f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -2439,72 +1812,31 @@ fn c128_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000000040864003f32)),
-            Value::F32((-9245928300000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000013903848f32)
-        )))
-    );
+    let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-3145897700000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000040864003f32)), Value::F32((-9245928300000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000013903848f32)))));
     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)),
-            Value::F32((-0.00000081292654f32)),
-            Value::F32((-0.00000000000000000000000000000000000015469397f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-489548160000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-93157.43f32)), Value::F32((-0.00000081292654f32)), Value::F32((-0.00000000000000000000000000000000000015469397f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-489548160000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((17887725000000000000000.0f32)),
-            Value::F32((514680230000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.0000000000000000000000000030930732f32))))
-    );
+    let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-0.00000000000000000000000000008899643f32)), Value::F32((17887725000000000000000.0f32)), Value::F32((514680230000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000030930732f32)))));
     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)),
-            Value::F32((33330492.0f32)),
-            Value::F32((-3253108800000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((9222036000000000000000000000000000.0f32)), Value::F32((33330492.0f32)), Value::F32((-3253108800000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -2513,10 +1845,7 @@ fn c132_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.0000000000000000000000000000000000018313439132919336f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009543270551003098f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-1093596114413331100000000000000.0f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-1093596114413331100000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -2570,7 +1899,7 @@ fn test_module_21() {
     c136_l328_action_invoke(&mut instance);
     c137_l329_action_invoke(&mut instance);
 }
-fn create_module_22() -> Box<Instance> {
+fn create_module_22() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64 f64) (result f64)))
@@ -2594,11 +1923,8 @@ fn create_module_22() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_22(instance: &mut Instance) {
@@ -2609,15 +1935,7 @@ fn start_module_22(instance: &mut Instance) {
 // 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)),
-            Value::F32((26125812000.0f32)),
-            Value::F32((-238608080000000.0f32)),
-            Value::F32((-2478953500000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_reassociate_add", &[Value::F32((-24154321000000.0f32)), Value::F32((26125812000.0f32)), Value::F32((-238608080000000.0f32)), Value::F32((-2478953500000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-265215220000000.0f32)))));
     result.map(|_| ())
 }
@@ -2625,15 +1943,7 @@ fn c139_l340_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.00985944f32)),
-            Value::F32((0.063375376f32)),
-            Value::F32((-0.011150199f32)),
-        ],
-    );
+    let result = instance.call("f32.no_reassociate_add", &[Value::F32((0.0036181053f32)), Value::F32((-0.00985944f32)), Value::F32((0.063375376f32)), Value::F32((-0.011150199f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.04598384f32)))));
     result.map(|_| ())
 }
@@ -2641,15 +1951,7 @@ fn c140_l341_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-3770877200000.0f32)),
-            Value::F32((30868425000000.0f32)),
-            Value::F32((421132080000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_reassociate_add", &[Value::F32((-34206968000.0f32)), Value::F32((-3770877200000.0f32)), Value::F32((30868425000000.0f32)), Value::F32((421132080000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((27484470000000.0f32)))));
     result.map(|_| ())
 }
@@ -2657,15 +1959,7 @@ fn c141_l342_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((925114700000000.0f32)),
-            Value::F32((-36021854000.0f32)),
-            Value::F32((2450846000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_reassociate_add", &[Value::F32((153506400000000.0f32)), Value::F32((925114700000000.0f32)), Value::F32((-36021854000.0f32)), Value::F32((2450846000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((3529431000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2673,19 +1967,8 @@ fn c142_l343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-396552040000000000000000000000000.0f32)),
-            Value::F32((48066940000000000000000000000000.0f32)),
-            Value::F32((-35644073000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((122079560000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_reassociate_add", &[Value::F32((470600300000000000000000000000000.0f32)), Value::F32((-396552040000000000000000000000000.0f32)), Value::F32((48066940000000000000000000000000.0f32)), Value::F32((-35644073000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((122079560000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -2747,7 +2030,7 @@ fn test_module_22() {
     c147_l348_action_invoke(&mut instance);
     c148_l349_action_invoke(&mut instance);
 }
-fn create_module_23() -> Box<Instance> {
+fn create_module_23() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64 f64) (result f64)))
@@ -2771,11 +2054,8 @@ fn create_module_23() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_23(instance: &mut Instance) {
@@ -2786,36 +2066,15 @@ fn start_module_23(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.00000000022548861f32)),
-            Value::F32((-6964322000000000000000000000000.0f32)),
-            Value::F32((0.000000000000000026902832f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.00000000000000000000000000000078764173f32)
-        )))
-    );
+    let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.00000000000000000000000000000000001904515f32)), Value::F32((0.00000000022548861f32)), Value::F32((-6964322000000000000000000000000.0f32)), Value::F32((0.000000000000000026902832f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000078764173f32)))));
     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)),
-            Value::F32((-7565904000000000000000000000000.0f32)),
-            Value::F32((-0.000000000000000000000000000000000000030807684f32)),
-            Value::F32((-1592759200000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.000000000000000018733125f32)), Value::F32((-7565904000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000030807684f32)), Value::F32((-1592759200000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0069547286f32)))));
     result.map(|_| ())
 }
@@ -2823,15 +2082,7 @@ fn c151_l361_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-56466884000000000.0f32)),
-            Value::F32((-0.0000000000011740512f32)),
-            Value::F32((84984730000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.0000000000000050355575f32)), Value::F32((-56466884000000000.0f32)), Value::F32((-0.0000000000011740512f32)), Value::F32((84984730000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((28370654000000.0f32)))));
     result.map(|_| ())
 }
@@ -2839,38 +2090,16 @@ fn c152_l362_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((254449360000000000000000.0f32)),
-            Value::F32((-72460980000000000.0f32)),
-            Value::F32((-962511040000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((823345100000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.000000000000000000000000000000046394946f32)), Value::F32((254449360000000000000000.0f32)), Value::F32((-72460980000000000.0f32)), Value::F32((-962511040000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((823345100000000000000000000.0f32)))));
     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)),
-            Value::F32((0.0000000000000023200355f32)),
-            Value::F32((-9.772748f32)),
-            Value::F32((864066000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.000000000000000000000000035113616f32))))
-    );
+    let result = instance.call("f32.no_reassociate_mul", &[Value::F32((-0.0000000000000000000000000000019420536f32)), Value::F32((0.0000000000000023200355f32)), Value::F32((-9.772748f32)), Value::F32((864066000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000035113616f32)))));
     result.map(|_| ())
 }
 
@@ -2932,7 +2161,7 @@ fn test_module_23() {
     c158_l368_action_invoke(&mut instance);
     c159_l369_action_invoke(&mut instance);
 }
-fn create_module_24() -> Box<Instance> {
+fn create_module_24() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -2948,11 +2177,8 @@ fn create_module_24() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_24(instance: &mut Instance) {
@@ -2994,75 +2220,45 @@ fn c164_l383_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c165_l384_assert_return_canonical_nan");
+    println!("Executing function {}", "c165_l384_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_0", &[Value::F32((0.0f32))]).unwrap().expect("Missing result in c165_l384_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c166_l385_assert_return_canonical_nan");
+    println!("Executing function {}", "c166_l385_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_0", &[Value::F32((-0.0f32))]).unwrap().expect("Missing result in c166_l385_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c167_l386_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c167_l386_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_div_0", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c167_l386_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c168_l387_assert_return_canonical_nan");
+    println!("Executing function {}", "c168_l387_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_0", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c168_l387_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -3100,75 +2296,45 @@ fn c172_l391_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c173_l392_assert_return_canonical_nan");
+    println!("Executing function {}", "c173_l392_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_0", &[Value::F64((0.0f64))]).unwrap().expect("Missing result in c173_l392_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c174_l393_assert_return_canonical_nan");
+    println!("Executing function {}", "c174_l393_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_0", &[Value::F64((-0.0f64))]).unwrap().expect("Missing result in c174_l393_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c175_l394_assert_return_canonical_nan");
+    println!("Executing function {}", "c175_l394_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_0", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c175_l394_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c176_l395_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c176_l395_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_div_0", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c176_l395_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -3196,7 +2362,7 @@ fn test_module_24() {
     c175_l394_assert_return_canonical_nan(&mut instance);
     c176_l395_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_25() -> Box<Instance> {
+fn create_module_25() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -3212,11 +2378,8 @@ fn create_module_25() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_25(instance: &mut Instance) {
@@ -3258,75 +2421,45 @@ fn c181_l409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c182_l410_assert_return_canonical_nan");
+    println!("Executing function {}", "c182_l410_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_neg0", &[Value::F32((0.0f32))]).unwrap().expect("Missing result in c182_l410_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c183_l411_assert_return_canonical_nan");
+    println!("Executing function {}", "c183_l411_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_neg0", &[Value::F32((-0.0f32))]).unwrap().expect("Missing result in c183_l411_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c184_l412_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c184_l412_assert_return_arithmetic_nan");
+    let result = instance.call("f32.no_fold_div_neg0", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c184_l412_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c185_l413_assert_return_canonical_nan");
+    println!("Executing function {}", "c185_l413_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_neg0", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c185_l413_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -3364,75 +2497,45 @@ fn c189_l417_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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))])
-        .unwrap()
-        .expect("Missing result in c190_l418_assert_return_canonical_nan");
+    println!("Executing function {}", "c190_l418_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_neg0", &[Value::F64((0.0f64))]).unwrap().expect("Missing result in c190_l418_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))])
-        .unwrap()
-        .expect("Missing result in c191_l419_assert_return_canonical_nan");
+    println!("Executing function {}", "c191_l419_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_neg0", &[Value::F64((-0.0f64))]).unwrap().expect("Missing result in c191_l419_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c192_l420_assert_return_canonical_nan");
+    println!("Executing function {}", "c192_l420_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_div_neg0", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c192_l420_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c193_l421_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c193_l421_assert_return_arithmetic_nan");
+    let result = instance.call("f64.no_fold_div_neg0", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c193_l421_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -3460,7 +2563,7 @@ fn test_module_25() {
     c192_l420_assert_return_canonical_nan(&mut instance);
     c193_l421_assert_return_arithmetic_nan(&mut instance);
 }
-fn create_module_26() -> Box<Instance> {
+fn create_module_26() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -3486,11 +2589,8 @@ fn create_module_26() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_26(instance: &mut Instance) {
@@ -3501,61 +2601,31 @@ fn start_module_26(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.0000000000000000000042365796f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000000042366535f32))))
-    );
+    let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((0.00000000000000000000000072854914f32)), Value::F32((0.0000000000000000000042365796f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000042366535f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000007453745f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000000007468044f32))))
-    );
+    let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-0.0000000000000000000007470285f32)), Value::F32((-0.000000000000000000000000000000007453745f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000007468044f32)))));
     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)),
-            Value::F32((-0.0000000000000000000032627214f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000000032627695f32))))
-    );
+    let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-0.0000000000000000000000000000000000770895f32)), Value::F32((-0.0000000000000000000032627214f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000032627695f32)))));
     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)), Value::F32((174209.48f32))],
-    );
+    let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-35.42818f32)), Value::F32((174209.48f32))]);
     assert_eq!(result, Ok(Some(Value::F32((174209.5f32)))));
     result.map(|_| ())
 }
@@ -3563,17 +2633,8 @@ fn c198_l437_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.00000000000000000000046344753f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.000000000000000000000463032f32))))
-    );
+    let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((0.000000000000000000000020628143f32)), Value::F32((-0.00000000000000000000046344753f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000463032f32)))));
     result.map(|_| ())
 }
 
@@ -3635,7 +2696,7 @@ fn test_module_26() {
     c203_l442_action_invoke(&mut instance);
     c204_l443_action_invoke(&mut instance);
 }
-fn create_module_27() -> Box<Instance> {
+fn create_module_27() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (func (;0;) (type 0) (param f32) (result f32)
@@ -3645,11 +2706,8 @@ fn create_module_27() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_27(instance: &mut Instance) {
@@ -3660,10 +2718,7 @@ fn start_module_27(instance: &mut Instance) {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.0011329757f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-882.6315f32)))));
     result.map(|_| ())
 }
@@ -3671,58 +2726,32 @@ fn c206_l452_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000003088774f32)
-        )))
-    );
+    let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((323753010000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000003088774f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-7857934600000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.0000000000000000000000000001272599f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-7857934600000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.000000000000000000000009706789f32))))
-    );
+    let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((103020680000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000009706789f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-3515709300000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.00000000000000000000000028443763f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-3515709300000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -3739,7 +2768,7 @@ fn test_module_27() {
     c209_l455_action_invoke(&mut instance);
     c210_l456_action_invoke(&mut instance);
 }
-fn create_module_28() -> Box<Instance> {
+fn create_module_28() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -3757,11 +2786,8 @@ fn create_module_28() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_28(instance: &mut Instance) {
@@ -3772,10 +2798,7 @@ fn start_module_28(instance: &mut Instance) {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000016117865f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2490842.5f32)))));
     result.map(|_| ())
 }
@@ -3783,10 +2806,7 @@ fn c212_l467_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.0074491366f32))]);
     assert_eq!(result, Ok(Some(Value::F32((11.58636f32)))));
     result.map(|_| ())
 }
@@ -3794,10 +2814,7 @@ fn c213_l468_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000000000002339817f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6537460000.0f32)))));
     result.map(|_| ())
 }
@@ -3805,10 +2822,7 @@ fn c214_l469_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000011123504f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2998328.3f32)))));
     result.map(|_| ())
 }
@@ -3816,10 +2830,7 @@ fn c215_l470_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.000000000000000000000000017653063f32))]);
     assert_eq!(result, Ok(Some(Value::F32((7526446300000.0f32)))));
     result.map(|_| ())
 }
@@ -3836,26 +2847,15 @@ fn c217_l473_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.000000000000000000000000000000000000000000000014505872638954843f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000014505872638954843f64)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.00000000000000018564920084793608f64))))
-    );
+    let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((29014415885392436000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000018564920084793608f64)))));
     result.map(|_| ())
 }
 
@@ -3870,18 +2870,8 @@ fn c220_l476_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.00000000000000000000008121860649480894f64)
-        )))
-    );
+    let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((151596415440704430000000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000008121860649480894f64)))));
     result.map(|_| ())
 }
 
@@ -3903,7 +2893,7 @@ fn test_module_28() {
     c220_l476_action_invoke(&mut instance);
     c221_l477_action_invoke(&mut instance);
 }
-fn create_module_29() -> Box<Instance> {
+fn create_module_29() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (func (;0;) (type 0) (param f32) (result f32)
@@ -3914,11 +2904,8 @@ fn create_module_29() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_29(instance: &mut Instance) {
@@ -3929,10 +2916,7 @@ fn start_module_29(instance: &mut Instance) {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((1895057100000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000072642176f32)))));
     result.map(|_| ())
 }
@@ -3940,10 +2924,7 @@ fn c223_l486_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((0.002565894f32))]);
     assert_eq!(result, Ok(Some(Value::F32((19.741522f32)))));
     result.map(|_| ())
 }
@@ -3951,10 +2932,7 @@ fn c224_l487_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((632654500000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.000000000039757284f32)))));
     result.map(|_| ())
 }
@@ -3962,10 +2940,7 @@ fn c225_l488_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((14153.539f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.008405576f32)))));
     result.map(|_| ())
 }
@@ -3973,10 +2948,7 @@ fn c226_l489_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((26173730000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000000000019546418f32)))));
     result.map(|_| ())
 }
@@ -3994,7 +2966,7 @@ fn test_module_29() {
     c226_l489_action_invoke(&mut instance);
     c227_l490_action_invoke(&mut instance);
 }
-fn create_module_30() -> Box<Instance> {
+fn create_module_30() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -4020,11 +2992,8 @@ fn create_module_30() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_30(instance: &mut Instance) {
@@ -4099,10 +3068,7 @@ fn c236_l514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -4126,10 +3092,7 @@ fn c239_l518_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -4154,7 +3117,7 @@ fn test_module_30() {
     c239_l518_action_invoke(&mut instance);
     c240_l519_action_invoke(&mut instance);
 }
-fn create_module_31() -> Box<Instance> {
+fn create_module_31() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -4174,11 +3137,8 @@ fn create_module_31() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_31(instance: &mut Instance) {
@@ -4189,13 +3149,7 @@ fn start_module_31(instance: &mut Instance) {
 // 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)),
-            Value::F32((-0.000000020946384f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_add_sub", &[Value::F32((0.000000000000012138282f32)), Value::F32((-0.000000020946384f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.000000000000012434498f32)))));
     result.map(|_| ())
 }
@@ -4203,13 +3157,7 @@ fn c242_l530_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000037154566f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-0.00000019768197f32)), Value::F32((0.0000037154566f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00000019768208f32)))));
     result.map(|_| ())
 }
@@ -4217,53 +3165,24 @@ fn c243_l531_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-3538041400000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-9671407000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-9596213000000000000000000.0f32)), Value::F32((-3538041400000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-9671407000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000024572656f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000000000049630837f32))))
-    );
+    let result = instance.call("f32.no_fold_add_sub", &[Value::F32((0.000000000000000000000005054346f32)), Value::F32((0.000000000000000024572656f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000049630837f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000071014917f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000006162976f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-0.0000000000000000000000000000000033693147f32)), Value::F32((-0.000000000000000000000000071014917f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000006162976f32)))));
     result.map(|_| ())
 }
 
@@ -4286,17 +3205,8 @@ fn c248_l537_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.1751431740707098f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000013604511406306585f64))))
-    );
+    let result = instance.call("f64.no_fold_add_sub", &[Value::F64((-0.0000000013604511322066714f64)), Value::F64((-0.1751431740707098f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000013604511406306585f64)))));
     result.map(|_| ())
 }
 
@@ -4334,7 +3244,7 @@ fn test_module_31() {
     c250_l539_action_invoke(&mut instance);
     c251_l540_action_invoke(&mut instance);
 }
-fn create_module_32() -> Box<Instance> {
+fn create_module_32() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -4354,11 +3264,8 @@ fn create_module_32() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_32(instance: &mut Instance) {
@@ -4369,10 +3276,7 @@ fn start_module_32(instance: &mut Instance) {
 // 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)), Value::F32((403.0368f32))],
-    );
+    let result = instance.call("f32.no_fold_sub_add", &[Value::F32((-676.47437f32)), Value::F32((403.0368f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-676.4744f32)))));
     result.map(|_| ())
 }
@@ -4380,29 +3284,15 @@ fn c253_l551_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000000000000367186f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.00000000000000000000000000000000063194576f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_sub_add", &[Value::F32((-0.0000000000000000000000000000000006305943f32)), Value::F32((0.0000000000000000000000000000367186f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000063194576f32)))));
     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)), Value::F32((46216217000.0f32))],
-    );
+    let result = instance.call("f32.no_fold_sub_add", &[Value::F32((83184800.0f32)), Value::F32((46216217000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((83185660.0f32)))));
     result.map(|_| ())
 }
@@ -4410,13 +3300,7 @@ fn c255_l553_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.00000001043793f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_sub_add", &[Value::F32((0.000000000002211957f32)), Value::F32((-0.00000001043793f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0000000000022115643f32)))));
     result.map(|_| ())
 }
@@ -4424,10 +3308,7 @@ fn c256_l554_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-27393.65f32))],
-    );
+    let result = instance.call("f32.no_fold_sub_add", &[Value::F32((0.14944395f32)), Value::F32((-27393.65f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.15039063f32)))));
     result.map(|_| ())
 }
@@ -4436,12 +3317,7 @@ fn c257_l555_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-958186427535552000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (90365982617946280000000000000000000000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((90365982617946280000000000000000000000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -4457,25 +3333,14 @@ fn c259_l558_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-4050190019576568700000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (4070815637249397500000000000000000000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((4070815637249397500000000000000000000000000000000000000000000000000000000000.0f64)))));
     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)),
-            Value::F64((-0.00017253797929188484f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_sub_add", &[Value::F64((0.000000024008889207554433f64)), Value::F64((-0.00017253797929188484f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.00000002400888920756506f64)))));
     result.map(|_| ())
 }
@@ -4506,7 +3371,7 @@ fn test_module_32() {
     c261_l560_action_invoke(&mut instance);
     c262_l561_action_invoke(&mut instance);
 }
-fn create_module_33() -> Box<Instance> {
+fn create_module_33() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -4526,11 +3391,8 @@ fn create_module_33() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_33(instance: &mut Instance) {
@@ -4541,13 +3403,7 @@ fn start_module_33(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.000000000000010121375f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-32476715000000000.0f32)), Value::F32((0.000000000000010121375f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-32476713000000000.0f32)))));
     result.map(|_| ())
 }
@@ -4555,13 +3411,7 @@ fn c264_l572_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000015799828f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.000000015561163f32)), Value::F32((0.000000000000000000000000000000015799828f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.000000015561145f32)))));
     result.map(|_| ())
 }
@@ -4569,13 +3419,7 @@ fn c265_l573_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-441324000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.00000000000000676311f32)), Value::F32((-441324000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000067631096f32)))));
     result.map(|_| ())
 }
@@ -4583,13 +3427,7 @@ fn c266_l574_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-2160384100000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_div", &[Value::F32((7505613700000000.0f32)), Value::F32((-2160384100000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((7505613000000000.0f32)))));
     result.map(|_| ())
 }
@@ -4597,19 +3435,8 @@ fn c267_l575_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000010808759f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.00000000000000000000000000023625765f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.0000000000000000000000000002362576f32)), Value::F32((-0.000000000010808759f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000023625765f32)))));
     result.map(|_| ())
 }
 
@@ -4633,12 +3460,7 @@ fn c270_l579_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009320036042623636f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-718011781190294750000000000000000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-718011781190294750000000000000000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -4646,12 +3468,7 @@ fn c271_l580_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003568792428129926f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.00000000000000000000000000000000000000000000000001661286799244216f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000001661286799244216f64)))));
     result.map(|_| ())
 }
 
@@ -4681,7 +3498,7 @@ fn test_module_33() {
     c272_l581_action_invoke(&mut instance);
     c273_l582_action_invoke(&mut instance);
 }
-fn create_module_34() -> Box<Instance> {
+fn create_module_34() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -4701,11 +3518,8 @@ fn create_module_34() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_34(instance: &mut Instance) {
@@ -4716,13 +3530,7 @@ fn start_module_34(instance: &mut Instance) {
 // 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)),
-            Value::F32((986062200.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-511517980000.0f32)), Value::F32((986062200.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-511517950000.0f32)))));
     result.map(|_| ())
 }
@@ -4730,72 +3538,32 @@ fn c275_l593_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0000041539834f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.00000000000000024944856f32))))
-    );
+    let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-0.00000000000000024944853f32)), Value::F32((-0.0000041539834f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000024944856f32)))));
     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)),
-            Value::F32((-235.19847f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000020828013f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_div_mul", &[Value::F32((0.000000000000000000000000000000000000020827855f32)), Value::F32((-235.19847f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000020828013f32)))));
     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)),
-            Value::F32((-696312600000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.00000000000000000000006249919f32))))
-    );
+    let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-0.000000000000000000000062499487f32)), Value::F32((-696312600000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000006249919f32)))));
     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)),
-            Value::F32((212781120.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000005835352f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_div_mul", &[Value::F32((0.0000000000000000000000000000058353514f32)), Value::F32((212781120.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000005835352f32)))));
     result.map(|_| ())
 }
 
@@ -4819,12 +3587,7 @@ fn c281_l600_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((942829809081919600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.000000000000000000000000000000000000000000031403419895426836f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000031403419895426836f64)))));
     result.map(|_| ())
 }
 
@@ -4862,7 +3625,7 @@ fn test_module_34() {
     c283_l602_action_invoke(&mut instance);
     c284_l603_action_invoke(&mut instance);
 }
-fn create_module_35() -> Box<Instance> {
+fn create_module_35() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -4882,11 +3645,8 @@ fn create_module_35() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_35(instance: &mut Instance) {
@@ -4897,18 +3657,8 @@ fn start_module_35(instance: &mut Instance) {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000023509887f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_div2_mul2", &[Value::F32((0.000000000000000000000000000000000000023509886f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32)))));
     result.map(|_| ())
 }
 
@@ -4930,7 +3680,7 @@ fn test_module_35() {
     c286_l614_action_invoke(&mut instance);
     c287_l615_action_invoke(&mut instance);
 }
-fn create_module_36() -> Box<Instance> {
+fn create_module_36() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64) (result f64)))
       (func (;0;) (type 0) (param f64) (result f64)
@@ -4940,11 +3690,8 @@ fn create_module_36() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_36(instance: &mut Instance) {
@@ -4955,82 +3702,40 @@ fn start_module_36(instance: &mut Instance) {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.00000000000000000000000000000000000000017176275796615013f64)
-        )))
-    );
+    let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.00000000000000000000000000000000000000017176297220569481f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000017176275796615013f64)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.00000000000000000000000002846477619188087f64)
-        )))
-    );
+    let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.000000000000000000000000028464775573304055f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000002846477619188087f64)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((208970700445326000000000000000000.0f64))))
-    );
+    let result = instance.call("no_fold_demote_promote", &[Value::F64((208970699699909230000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((208970700445326000000000000000000.0f64)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.0000000000000000000000000047074161331556024f64)
-        )))
-    );
+    let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.0000000000000000000000000047074160416121775f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000047074161331556024f64)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((23359452224542198000000000000000.0f64))))
-    );
+    let result = instance.call("no_fold_demote_promote", &[Value::F64((23359451497950880000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((23359452224542198000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -5047,7 +3752,7 @@ fn test_module_36() {
     c292_l627_action_invoke(&mut instance);
     c293_l628_action_invoke(&mut instance);
 }
-fn create_module_37() -> Box<Instance> {
+fn create_module_37() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (func (;0;) (type 0) (param f32) (result f32)
@@ -5057,11 +3762,8 @@ fn create_module_37() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_37(instance: &mut Instance) {
@@ -5071,21 +3773,12 @@ fn start_module_37(instance: &mut Instance) {
 
 // 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))],
-        )
-        .unwrap()
-        .expect("Missing result in c295_l638_assert_return_arithmetic_nan");
+    println!("Executing function {}", "c295_l638_assert_return_arithmetic_nan");
+    let result = instance.call("no_fold_promote_demote", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c295_l638_assert_return_arithmetic_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -5108,140 +3801,64 @@ fn c297_l640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000011754942f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000011754942f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("no_fold_promote_demote", &[Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("no_fold_promote_demote", &[Value::F32((-340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -5282,7 +3899,7 @@ fn test_module_37() {
     c306_l649_action_invoke(&mut instance);
     c307_l650_action_invoke(&mut instance);
 }
-fn create_module_38() -> Box<Instance> {
+fn create_module_38() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64 f32) (result f32)))
       (type (;1;) (func (param f32 f64) (result f32)))
@@ -5302,11 +3919,8 @@ fn create_module_38() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_38(instance: &mut Instance) {
@@ -5317,32 +3931,15 @@ fn start_module_38(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.0000000000000000000000000000000000018767183f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000049412667f32)
-        )))
-    );
+    let result = instance.call("no_demote_mixed_add", &[Value::F64((0.00000000000000000000000000004941266527909197f64)), Value::F32((0.0000000000000000000000000000000000018767183f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000049412667f32)))));
     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)),
-            Value::F32((401096440000.0f32)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_add", &[Value::F64((140851523637.69385f64)), Value::F32((401096440000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((541947950000.0f32)))));
     result.map(|_| ())
 }
@@ -5350,32 +3947,15 @@ fn c310_l662_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0000000000000000000000000000000000006050095f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.0000000000000000000000000000000000014781066f32)
-        )))
-    );
+    let result = instance.call("no_demote_mixed_add", &[Value::F64((0.0000000000000000000000000000000000020831160914192852f64)), Value::F32((-0.0000000000000000000000000000000000006050095f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000014781066f32)))));
     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)),
-            Value::F32((0.0000000019312918f32)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_add", &[Value::F64((-0.0000010032827553674626f64)), Value::F32((0.0000000019312918f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000010013515f32)))));
     result.map(|_| ())
 }
@@ -5383,13 +3963,7 @@ fn c312_l664_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0000000000005202814f32)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_add", &[Value::F64((-0.0000013840207035752711f64)), Value::F32((-0.0000000000005202814f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000013840212f32)))));
     result.map(|_| ())
 }
@@ -5397,32 +3971,15 @@ fn c313_l665_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.00000000000000000000000000004941266527909197f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000049412667f32)
-        )))
-    );
+    let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((0.0000000000000000000000000000000000018767183f32)), Value::F64((0.00000000000000000000000000004941266527909197f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000049412667f32)))));
     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)),
-            Value::F64((140851523637.69385f64)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((401096440000.0f32)), Value::F64((140851523637.69385f64))]);
     assert_eq!(result, Ok(Some(Value::F32((541947950000.0f32)))));
     result.map(|_| ())
 }
@@ -5430,32 +3987,15 @@ fn c315_l668_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0000000000000000000000000000000000020831160914192852f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.0000000000000000000000000000000000014781066f32)
-        )))
-    );
+    let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((-0.0000000000000000000000000000000000006050095f32)), Value::F64((0.0000000000000000000000000000000000020831160914192852f64))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000014781066f32)))));
     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)),
-            Value::F64((-0.0000010032827553674626f64)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((0.0000000019312918f32)), Value::F64((-0.0000010032827553674626f64))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000010013515f32)))));
     result.map(|_| ())
 }
@@ -5463,13 +4003,7 @@ fn c317_l670_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-0.0000013840207035752711f64)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((-0.0000000000005202814f32)), Value::F64((-0.0000013840207035752711f64))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000013840212f32)))));
     result.map(|_| ())
 }
@@ -5492,7 +4026,7 @@ fn test_module_38() {
     c317_l670_action_invoke(&mut instance);
     c318_l671_action_invoke(&mut instance);
 }
-fn create_module_39() -> Box<Instance> {
+fn create_module_39() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64 f32) (result f32)))
       (func (;0;) (type 0) (param f64 f32) (result f32)
@@ -5504,11 +4038,8 @@ fn create_module_39() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_39(instance: &mut Instance) {
@@ -5519,30 +4050,15 @@ fn start_module_39(instance: &mut Instance) {
 // 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)),
-            Value::F32((4086347000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((7869931000000000000000000.0f32))))
-    );
+    let result = instance.call("no_demote_mixed_sub", &[Value::F64((7869935327202668000000000.0f64)), Value::F32((4086347000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((7869931000000000000000000.0f32)))));
     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)),
-            Value::F32((239897.28f32)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_sub", &[Value::F64((-1535841968.9056544f64)), Value::F32((239897.28f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1536081900.0f32)))));
     result.map(|_| ())
 }
@@ -5550,13 +4066,7 @@ fn c321_l681_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00039426138f32)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_sub", &[Value::F64((-102.19459272722602f64)), Value::F32((0.00039426138f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-102.194984f32)))));
     result.map(|_| ())
 }
@@ -5564,13 +4074,7 @@ fn c322_l682_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000005851077f32)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_sub", &[Value::F64((0.00000000000000005645470375565188f64)), Value::F32((0.0000000000000000000005851077f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000000000005645412f32)))));
     result.map(|_| ())
 }
@@ -5578,13 +4082,7 @@ fn c323_l683_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((63120.89f32)),
-        ],
-    );
+    let result = instance.call("no_demote_mixed_sub", &[Value::F64((27090.388466832894f64)), Value::F32((63120.89f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-36030.504f32)))));
     result.map(|_| ())
 }
@@ -5602,7 +4100,7 @@ fn test_module_39() {
     c323_l683_action_invoke(&mut instance);
     c324_l684_action_invoke(&mut instance);
 }
-fn create_module_40() -> Box<Instance> {
+fn create_module_40() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -5688,11 +4186,8 @@ fn create_module_40() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_40(instance: &mut Instance) {
@@ -5711,10 +4206,7 @@ fn c326_l723_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.i32.no_fold_trunc_s_convert_s", &[Value::F32((-1.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -5730,10 +4222,7 @@ fn c328_l725_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.i32.no_fold_trunc_u_convert_s", &[Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -5749,10 +4238,7 @@ fn c330_l727_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.i32.no_fold_trunc_s_convert_u", &[Value::F32((-1.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((4294967300.0f32)))));
     result.map(|_| ())
 }
@@ -5768,10 +4254,7 @@ fn c332_l729_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.i32.no_fold_trunc_u_convert_u", &[Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -5787,10 +4270,7 @@ fn c334_l732_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.i32.no_fold_trunc_s_convert_s", &[Value::F64((-1.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -5806,10 +4286,7 @@ fn c336_l734_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.i32.no_fold_trunc_u_convert_s", &[Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -5825,10 +4302,7 @@ fn c338_l736_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.i32.no_fold_trunc_s_convert_u", &[Value::F64((-1.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((4294967295.0f64)))));
     result.map(|_| ())
 }
@@ -5844,10 +4318,7 @@ fn c340_l738_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.i32.no_fold_trunc_u_convert_u", &[Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -5863,10 +4334,7 @@ fn c342_l741_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.i64.no_fold_trunc_s_convert_s", &[Value::F32((-1.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1.0f32)))));
     result.map(|_| ())
 }
@@ -5882,10 +4350,7 @@ fn c344_l743_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.i64.no_fold_trunc_u_convert_s", &[Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -5901,10 +4366,7 @@ fn c346_l745_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.i64.no_fold_trunc_s_convert_u", &[Value::F32((-1.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((18446744000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -5920,10 +4382,7 @@ fn c348_l747_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.i64.no_fold_trunc_u_convert_u", &[Value::F32((-0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -5939,10 +4398,7 @@ fn c350_l750_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.i64.no_fold_trunc_s_convert_s", &[Value::F64((-1.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-1.0f64)))));
     result.map(|_| ())
 }
@@ -5958,10 +4414,7 @@ fn c352_l752_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.i64.no_fold_trunc_u_convert_s", &[Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -5977,10 +4430,7 @@ fn c354_l754_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.i64.no_fold_trunc_s_convert_u", &[Value::F64((-1.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((18446744073709552000.0f64)))));
     result.map(|_| ())
 }
@@ -5996,10 +4446,7 @@ fn c356_l756_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.i64.no_fold_trunc_u_convert_u", &[Value::F64((-0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -6044,7 +4491,7 @@ fn test_module_40() {
     c356_l756_action_invoke(&mut instance);
     c357_l757_action_invoke(&mut instance);
 }
-fn create_module_41() -> Box<Instance> {
+fn create_module_41() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 f32)))
       (type (;1;) (func (param i32) (result f32)))
@@ -6081,11 +4528,8 @@ fn create_module_41() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_41(instance: &mut Instance) {
@@ -6097,7 +4541,7 @@ fn start_module_41(instance: &mut Instance) {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6105,7 +4549,7 @@ fn c359_l784_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6113,7 +4557,7 @@ fn c360_l785_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6121,7 +4565,7 @@ fn c361_l786_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6161,7 +4605,7 @@ fn c366_l791_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6218,7 +4662,7 @@ fn test_module_41() {
     c370_l795_action_invoke(&mut instance);
     c371_l796_action_invoke(&mut instance);
 }
-fn create_module_42() -> Box<Instance> {
+fn create_module_42() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 f64)))
       (type (;1;) (func (param i32) (result f64)))
@@ -6255,11 +4699,8 @@ fn create_module_42() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_42(instance: &mut Instance) {
@@ -6271,7 +4712,7 @@ fn start_module_42(instance: &mut Instance) {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6279,7 +4720,7 @@ fn c373_l819_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6287,7 +4728,7 @@ fn c374_l820_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6295,7 +4736,7 @@ fn c375_l821_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6335,7 +4776,7 @@ fn c380_l826_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-
+    
     result.map(|_| ())
 }
 
@@ -6392,7 +4833,7 @@ fn test_module_42() {
     c384_l830_action_invoke(&mut instance);
     c385_l831_action_invoke(&mut instance);
 }
-fn create_module_43() -> Box<Instance> {
+fn create_module_43() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result i32)))
       (type (;1;) (func (param f64 f64) (result i32)))
@@ -6446,11 +4887,8 @@ fn create_module_43() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_43(instance: &mut Instance) {
@@ -6485,10 +4923,7 @@ fn c389_l849_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.ult", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6520,10 +4955,7 @@ fn c393_l853_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.ule", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6555,10 +4987,7 @@ fn c397_l857_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.ugt", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6590,10 +5019,7 @@ fn c401_l861_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.uge", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6625,13 +5051,7 @@ fn c405_l865_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.ult", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6663,13 +5083,7 @@ fn c409_l869_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.ule", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6701,13 +5115,7 @@ fn c413_l873_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.ugt", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6739,13 +5147,7 @@ fn c417_l877_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.uge", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -6790,7 +5192,7 @@ fn test_module_43() {
     c417_l877_action_invoke(&mut instance);
     c418_l878_action_invoke(&mut instance);
 }
-fn create_module_44() -> Box<Instance> {
+fn create_module_44() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -6860,11 +5262,8 @@ fn create_module_44() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_44(instance: &mut Instance) {
@@ -6875,30 +5274,21 @@ fn start_module_44(instance: &mut Instance) {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_fold_lt_select", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_lt_select", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -6906,10 +5296,7 @@ fn c421_l895_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_lt_select", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -6917,10 +5304,7 @@ fn c422_l896_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_lt_select", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -6928,30 +5312,21 @@ fn c423_l897_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_fold_le_select", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_le_select", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -6959,10 +5334,7 @@ fn c425_l899_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_le_select", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -6970,10 +5342,7 @@ fn c426_l900_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_le_select", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -6981,30 +5350,21 @@ fn c427_l901_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_fold_gt_select", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_gt_select", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7012,10 +5372,7 @@ fn c429_l903_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_gt_select", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -7023,10 +5380,7 @@ fn c430_l904_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_gt_select", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7034,30 +5388,21 @@ fn c431_l905_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_fold_ge_select", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_ge_select", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7065,10 +5410,7 @@ fn c433_l907_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_ge_select", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7076,10 +5418,7 @@ fn c434_l908_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_ge_select", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -7087,36 +5426,21 @@ fn c435_l909_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_lt_select", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_lt_select", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7124,10 +5448,7 @@ fn c437_l911_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_lt_select", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -7135,10 +5456,7 @@ fn c438_l912_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_lt_select", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7146,36 +5464,21 @@ fn c439_l913_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_le_select", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_le_select", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7183,10 +5486,7 @@ fn c441_l915_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_le_select", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7194,10 +5494,7 @@ fn c442_l916_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_le_select", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -7205,36 +5502,21 @@ fn c443_l917_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_gt_select", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_gt_select", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7242,10 +5524,7 @@ fn c445_l919_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_gt_select", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -7253,10 +5532,7 @@ fn c446_l920_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_gt_select", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7264,36 +5540,21 @@ fn c447_l921_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_ge_select", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_ge_select", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7301,10 +5562,7 @@ fn c449_l923_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_ge_select", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7312,10 +5570,7 @@ fn c450_l924_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_ge_select", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -7360,7 +5615,7 @@ fn test_module_44() {
     c450_l924_action_invoke(&mut instance);
     c451_l925_action_invoke(&mut instance);
 }
-fn create_module_45() -> Box<Instance> {
+fn create_module_45() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -7446,11 +5701,8 @@ fn create_module_45() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_45(instance: &mut Instance) {
@@ -7461,30 +5713,21 @@ fn start_module_45(instance: &mut Instance) {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_fold_lt_if", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_lt_if", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7492,10 +5735,7 @@ fn c454_l974_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_lt_if", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -7503,10 +5743,7 @@ fn c455_l975_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_lt_if", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7514,30 +5751,21 @@ fn c456_l976_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_fold_le_if", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_le_if", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7545,10 +5773,7 @@ fn c458_l978_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_le_if", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7556,10 +5781,7 @@ fn c459_l979_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_le_if", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -7567,30 +5789,21 @@ fn c460_l980_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_fold_gt_if", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_gt_if", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7598,10 +5811,7 @@ fn c462_l982_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_gt_if", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -7609,10 +5819,7 @@ fn c463_l983_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_gt_if", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7620,30 +5827,21 @@ fn c464_l984_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_fold_ge_if", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_ge_if", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7651,10 +5849,7 @@ fn c466_l986_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_ge_if", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -7662,10 +5857,7 @@ fn c467_l987_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_ge_if", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -7673,36 +5865,21 @@ fn c468_l988_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_lt_if", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_lt_if", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7710,10 +5887,7 @@ fn c470_l990_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_lt_if", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -7721,10 +5895,7 @@ fn c471_l991_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_lt_if", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7732,36 +5903,21 @@ fn c472_l992_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_le_if", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_le_if", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7769,10 +5925,7 @@ fn c474_l994_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_le_if", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7780,10 +5933,7 @@ fn c475_l995_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_le_if", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -7791,36 +5941,21 @@ fn c476_l996_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_gt_if", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_gt_if", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7828,10 +5963,7 @@ fn c478_l998_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_gt_if", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -7839,10 +5971,7 @@ fn c479_l999_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_gt_if", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7850,36 +5979,21 @@ fn c480_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_ge_if", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_ge_if", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7887,10 +6001,7 @@ fn c482_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_ge_if", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -7898,10 +6009,7 @@ fn c483_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_ge_if", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -7946,7 +6054,7 @@ fn test_module_45() {
     c483_l1003_action_invoke(&mut instance);
     c484_l1004_action_invoke(&mut instance);
 }
-fn create_module_46() -> Box<Instance> {
+fn create_module_46() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -8024,11 +6132,8 @@ fn create_module_46() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_46(instance: &mut Instance) {
@@ -8039,40 +6144,28 @@ fn start_module_46(instance: &mut Instance) {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_lt_select_to_abs", &[Value::F32(f32::from_bits(2141192192))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f32.no_fold_lt_select_to_abs", &[Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8095,40 +6188,28 @@ fn c489_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_le_select_to_abs", &[Value::F32(f32::from_bits(2141192192))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f32.no_fold_le_select_to_abs", &[Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8151,40 +6232,28 @@ fn c493_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_gt_select_to_abs", &[Value::F32(f32::from_bits(2141192192))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f32.no_fold_gt_select_to_abs", &[Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8207,40 +6276,28 @@ fn c497_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_ge_select_to_abs", &[Value::F32(f32::from_bits(2141192192))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f32.no_fold_ge_select_to_abs", &[Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8263,40 +6320,28 @@ fn c501_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_lt_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.no_fold_lt_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8319,40 +6364,28 @@ fn c505_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_le_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.no_fold_le_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8375,40 +6408,28 @@ fn c509_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_gt_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.no_fold_gt_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8431,40 +6452,28 @@ fn c513_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_ge_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.no_fold_ge_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8524,7 +6533,7 @@ fn test_module_46() {
     c516_l1050_action_invoke(&mut instance);
     c517_l1051_action_invoke(&mut instance);
 }
-fn create_module_47() -> Box<Instance> {
+fn create_module_47() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -8618,11 +6627,8 @@ fn create_module_47() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_47(instance: &mut Instance) {
@@ -8633,40 +6639,28 @@ fn start_module_47(instance: &mut Instance) {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_lt_if_to_abs", &[Value::F32(f32::from_bits(2141192192))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f32.no_fold_lt_if_to_abs", &[Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8689,40 +6683,28 @@ fn c522_l1102_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_le_if_to_abs", &[Value::F32(f32::from_bits(2141192192))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f32.no_fold_le_if_to_abs", &[Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8745,40 +6727,28 @@ fn c526_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_gt_if_to_abs", &[Value::F32(f32::from_bits(2141192192))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f32.no_fold_gt_if_to_abs", &[Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8801,40 +6771,28 @@ fn c530_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_ge_if_to_abs", &[Value::F32(f32::from_bits(2141192192))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f32.no_fold_ge_if_to_abs", &[Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8857,40 +6815,28 @@ fn c534_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_lt_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.no_fold_lt_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8913,40 +6859,28 @@ fn c538_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_le_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.no_fold_le_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -8969,40 +6903,28 @@ fn c542_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_gt_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.no_fold_gt_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -9025,40 +6947,28 @@ fn c546_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.no_fold_ge_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.no_fold_ge_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -9118,7 +7028,7 @@ fn test_module_47() {
     c549_l1129_action_invoke(&mut instance);
     c550_l1130_action_invoke(&mut instance);
 }
-fn create_module_48() -> Box<Instance> {
+fn create_module_48() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f32)))
       (type (;1;) (func (result f64)))
@@ -9142,11 +7052,8 @@ fn create_module_48() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_48(instance: &mut Instance) {
@@ -9166,10 +7073,7 @@ fn c552_l1144_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64)))));
     result.map(|_| ())
 }
 
@@ -9183,7 +7087,7 @@ fn test_module_48() {
     c552_l1144_action_invoke(&mut instance);
     c553_l1145_action_invoke(&mut instance);
 }
-fn create_module_49() -> Box<Instance> {
+fn create_module_49() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f32)))
       (func (;0;) (type 0) (result f32)
@@ -9227,11 +7131,8 @@ fn create_module_49() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_49(instance: &mut Instance) {
@@ -9256,7 +7157,7 @@ fn test_module_49() {
     start_module_49(&mut instance);
     c555_l1167_action_invoke(&mut instance);
 }
-fn create_module_50() -> Box<Instance> {
+fn create_module_50() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f64)))
       (func (;0;) (type 0) (result f64)
@@ -9300,11 +7201,8 @@ fn create_module_50() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_50(instance: &mut Instance) {
@@ -9329,7 +7227,7 @@ fn test_module_50() {
     start_module_50(&mut instance);
     c557_l1186_action_invoke(&mut instance);
 }
-fn create_module_51() -> Box<Instance> {
+fn create_module_51() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (func (;0;) (type 0) (param f32) (result f32)
@@ -9341,11 +7239,8 @@ fn create_module_51() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_51(instance: &mut Instance) {
@@ -9370,7 +7265,7 @@ fn test_module_51() {
     start_module_51(&mut instance);
     c559_l1197_action_invoke(&mut instance);
 }
-fn create_module_52() -> Box<Instance> {
+fn create_module_52() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result f32)))
       (func (;0;) (type 0) (param i32) (result f32)
@@ -9383,11 +7278,8 @@ fn create_module_52() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_52(instance: &mut Instance) {
@@ -9412,7 +7304,7 @@ fn test_module_52() {
     start_module_52(&mut instance);
     c561_l1208_action_invoke(&mut instance);
 }
-fn create_module_53() -> Box<Instance> {
+fn create_module_53() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result f32)))
       (func (;0;) (type 0) (param i32 i32) (result f32)
@@ -9428,11 +7320,8 @@ fn create_module_53() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_53(instance: &mut Instance) {
@@ -9443,10 +7332,7 @@ fn start_module_53(instance: &mut Instance) {
 // 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)],
-    );
+    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)))));
     result.map(|_| ())
 }
@@ -9460,7 +7346,7 @@ fn test_module_53() {
     start_module_53(&mut instance);
     c563_l1220_action_invoke(&mut instance);
 }
-fn create_module_54() -> Box<Instance> {
+fn create_module_54() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64 f64 f64 f64) (result f64)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -9490,11 +7376,8 @@ fn create_module_54() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_54(instance: &mut Instance) {
@@ -9513,40 +7396,16 @@ fn c565_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.9999999999999999f64)),
-            Value::F64((0.00000000000000005551115123125783f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.000000000000000000000000000000006162975822039155f64)
-        )))
-    );
+    let result = instance.call("thepast1", &[Value::F64((0.00000000000000005551115123125783f64)), Value::F64((0.9999999999999999f64)), Value::F64((0.00000000000000005551115123125783f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000006162975822039155f64)))));
     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)),
-            Value::F32((0.5f32)),
-            Value::F32((1.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("thepast2", &[Value::F32((0.000000000000000000000000000000000000023509887f32)), Value::F32((0.5f32)), Value::F32((1.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -9561,7 +7420,7 @@ fn test_module_54() {
     c566_l1245_action_invoke(&mut instance);
     c567_l1246_action_invoke(&mut instance);
 }
-fn create_module_55() -> Box<Instance> {
+fn create_module_55() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (func (;0;) (type 0) (param f32) (result f32)
@@ -9571,11 +7430,8 @@ fn create_module_55() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_55(instance: &mut Instance) {
@@ -9600,7 +7456,7 @@ fn test_module_55() {
     start_module_55(&mut instance);
     c569_l1257_action_invoke(&mut instance);
 }
-fn create_module_56() -> Box<Instance> {
+fn create_module_56() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -9618,11 +7474,8 @@ fn create_module_56() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_56(instance: &mut Instance) {
@@ -9656,7 +7509,7 @@ fn test_module_56() {
     c571_l1272_action_invoke(&mut instance);
     c572_l1273_action_invoke(&mut instance);
 }
-fn create_module_57() -> Box<Instance> {
+fn create_module_57() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -9676,11 +7529,8 @@ fn create_module_57() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_57(instance: &mut Instance) {
@@ -9691,10 +7541,7 @@ fn start_module_57(instance: &mut Instance) {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((-70435790000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-70435784000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -9702,28 +7549,16 @@ fn c574_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000000000124661f32))))
-    );
+    let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((0.000000000000000000000012466101f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000124661f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.00000000000000000009718455f32))))
-    );
+    let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((0.000000000000000000097184545f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000009718455f32)))));
     result.map(|_| ())
 }
 
@@ -9738,10 +7573,7 @@ fn c577_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((2331659200000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2331659000000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -9781,28 +7613,15 @@ fn c582_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-657971534362886900000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((-657971534362886860000000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-657971534362886900000000000000000000000000000.0f64)))));
     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))],
-    );
+    let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((-144246931868576430000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-144246931868576420000.0f64)))));
     result.map(|_| ())
 }
@@ -9810,18 +7629,8 @@ fn c584_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (184994689206231330000000000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((184994689206231350000000000000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((184994689206231330000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -9899,7 +7708,7 @@ fn test_module_57() {
     c590_l1304_action_invoke(&mut instance);
     c591_l1305_action_invoke(&mut instance);
 }
-fn create_module_58() -> Box<Instance> {
+fn create_module_58() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -9923,11 +7732,8 @@ fn create_module_58() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_58(instance: &mut Instance) {
@@ -9938,29 +7744,15 @@ fn start_module_58(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.00000000000000009744328f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000006610229f32)
-        )))
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-0.000000000000000053711865f32)), Value::F32((0.00000000000000009744328f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000006610229f32)))));
     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)), Value::F32((32770204.0f32))],
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-19756732.0f32)), Value::F32((32770204.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-683557800000000.0f32)))));
     result.map(|_| ())
 }
@@ -9968,27 +7760,15 @@ fn c594_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-145309980000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-18378221000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((52314150000000.0f32)), Value::F32((-145309980000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-18378221000000000000000000000.0f32)))));
     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)), Value::F32((-227.75723f32))],
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((195260.38f32)), Value::F32((-227.75723f32))]);
     assert_eq!(result, Ok(Some(Value::F32((38126563000.0f32)))));
     result.map(|_| ())
 }
@@ -9996,10 +7776,7 @@ fn c596_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-972341.5f32))],
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-237.48706f32)), Value::F32((-972341.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-945447960000.0f32)))));
     result.map(|_| ())
 }
@@ -10031,13 +7808,7 @@ fn c600_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((662717187728034000000000000000000000000000000000000000000.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-1292099281007814900000000000000000000000000000000000000.0f64)), Value::F64((662717187728034000000000000000000000000000000000000000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-439192401389602300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
@@ -10045,19 +7816,8 @@ fn c601_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1625023398605080200000000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (688684325575149100000000000000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((26242795689010570000000000000000000.0f64)), Value::F64((-1625023398605080200000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((688684325575149100000000000000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -10079,7 +7839,7 @@ fn test_module_58() {
     c601_l1328_action_invoke(&mut instance);
     c602_l1329_action_invoke(&mut instance);
 }
-fn create_module_59() -> Box<Instance> {
+fn create_module_59() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -10103,11 +7863,8 @@ fn create_module_59() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_59(instance: &mut Instance) {
@@ -10118,47 +7875,23 @@ fn start_module_59(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.0000000000031465275f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.0000000000000000000000099001476f32))))
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.000000000000022102996f32)), Value::F32((0.0000000000031465275f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000099001476f32)))));
     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)),
-            Value::F32((-15941539000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((10820299000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-3289460800000.0f32)), Value::F32((-15941539000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((10820299000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.00016153714f32)),
-        ],
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.00036497542f32)), Value::F32((-0.00016153714f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.000000107112804f32)))));
     result.map(|_| ())
 }
@@ -10166,34 +7899,16 @@ fn c606_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000027412773f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.000000000000000000000000003523511f32))))
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.000000000000065383266f32)), Value::F32((-0.000000000000027412773f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000003523511f32)))));
     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)),
-            Value::F32((-5260104400000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-14638896000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((3609682000000000.0f32)), Value::F32((-5260104400000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-14638896000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -10216,30 +7931,15 @@ fn c610_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-970738900948.5906f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((29063233895797397000000000.0f64))))
-    );
+    let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((5477733829752.252f64)), Value::F64((-970738900948.5906f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((29063233895797397000000000.0f64)))));
     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)),
-            Value::F64((-173378393593738040000000000000000000000000000000000.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-10689141744923551000000000000000000000000000000000000000.0f64)), Value::F64((-173378393593738040000000000000000000000000000000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((114257751213007240000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
@@ -10270,7 +7970,7 @@ fn test_module_59() {
     c612_l1352_action_invoke(&mut instance);
     c613_l1353_action_invoke(&mut instance);
 }
-fn create_module_60() -> Box<Instance> {
+fn create_module_60() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32 i32)))
       (type (;1;) (func (param i32) (result f32)))
@@ -10329,11 +8029,8 @@ fn create_module_60() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_60(instance: &mut Instance) {
@@ -10344,14 +8041,7 @@ fn start_module_60(instance: &mut Instance) {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -10360,12 +8050,7 @@ fn c615_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32)))));
     result.map(|_| ())
 }
 
@@ -10381,12 +8066,7 @@ fn c617_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -10394,12 +8074,7 @@ fn c618_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -10416,7 +8091,7 @@ fn test_module_60() {
     c618_l1394_action_invoke(&mut instance);
     c619_l1395_action_invoke(&mut instance);
 }
-fn create_module_61() -> Box<Instance> {
+fn create_module_61() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32 i32)))
       (type (;1;) (func (param i32) (result f64)))
@@ -10475,11 +8150,8 @@ fn create_module_61() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_61(instance: &mut Instance) {
@@ -10490,14 +8162,7 @@ fn start_module_61(instance: &mut Instance) {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -10547,7 +8212,7 @@ fn test_module_61() {
     c624_l1433_action_invoke(&mut instance);
     c625_l1434_action_invoke(&mut instance);
 }
-fn create_module_62() -> Box<Instance> {
+fn create_module_62() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result f32)))
       (func (;0;) (type 0) (param i32 i32) (result f32)
@@ -10609,11 +8274,8 @@ fn create_module_62() -> Box<Instance> {
       (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<b6\\be\\12\\fd6\\7f\\88>\\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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_62(instance: &mut Instance) {
@@ -10624,28 +8286,16 @@ fn start_module_62(instance: &mut Instance) {
 // 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))))
-    );
+    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)))));
     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))))
-    );
+    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)))));
     result.map(|_| ())
 }
 
@@ -10659,7 +8309,7 @@ fn test_module_62() {
     c627_l1530_action_invoke(&mut instance);
     c628_l1531_action_invoke(&mut instance);
 }
-fn create_module_63() -> Box<Instance> {
+fn create_module_63() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result f64)))
       (func (;0;) (type 0) (param i32 i32) (result f64)
@@ -10721,11 +8371,8 @@ fn create_module_63() -> Box<Instance> {
       (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\\bc0<U\\b2$\\9at:\\9e\\e1\\d8\\0fp\\fc\\a9:\\cd\\93K\\ec\\e3~\\dd]'\\cd\\f8\\a0\\9d\\1c\\11\\c0W.\\fd\\c8\\132\\cc:\\1a}\\a3AU\\ed\\c3\\82I*\\04\\1e\\efs\\b9..\\e3_\\f4\\df\\e6\\b23\\0c9?oDj\\03\\c1B\\b9\\fa\\b1\\c8\\ed\\a5X\\99\\7f\\ed\\b4r\\9ey\\eb\\fbC\\82E\\aa\\bb\\95\\d2\\ff(\\9e\\f6\\a1\\ad\\95\\d6U\\95\\0do`\\11\\c7x>I\\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<d\\22\\12<\\22\\90d-0TL\\b4\\a1\\22\\09W\\22^\\8e8+\\02\\a8\\ae\\f6\\be\\0d+\\f2\\03\\ad\\fa\\10\\01qw*0\\02\\95\\f6\\00>\\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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_63(instance: &mut Instance) {
@@ -10736,10 +8383,7 @@ fn start_module_63(instance: &mut Instance) {
 // 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)],
-    );
+    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)))));
     result.map(|_| ())
 }
@@ -10747,10 +8391,7 @@ fn c630_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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)))));
     result.map(|_| ())
 }
@@ -10765,7 +8406,7 @@ fn test_module_63() {
     c630_l1581_action_invoke(&mut instance);
     c631_l1582_action_invoke(&mut instance);
 }
-fn create_module_64() -> Box<Instance> {
+fn create_module_64() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -10783,11 +8424,8 @@ fn create_module_64() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_64(instance: &mut Instance) {
@@ -10798,10 +8436,7 @@ fn start_module_64(instance: &mut Instance) {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_neg_sub", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -10809,10 +8444,7 @@ fn c633_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_neg_sub", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -10820,10 +8452,7 @@ fn c634_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_neg_sub", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -10831,10 +8460,7 @@ fn c635_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_neg_sub", &[Value::F32((0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -10842,10 +8468,7 @@ fn c636_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -10853,10 +8476,7 @@ fn c637_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -10864,10 +8484,7 @@ fn c638_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -10875,10 +8492,7 @@ fn c639_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -10899,7 +8513,7 @@ fn test_module_64() {
     c639_l1601_action_invoke(&mut instance);
     c640_l1602_action_invoke(&mut instance);
 }
-fn create_module_65() -> Box<Instance> {
+fn create_module_65() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -10917,11 +8531,8 @@ fn create_module_65() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_65(instance: &mut Instance) {
@@ -10932,10 +8543,7 @@ fn start_module_65(instance: &mut Instance) {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_neg_add", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -10943,10 +8551,7 @@ fn c642_l1614_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_neg_add", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -10954,10 +8559,7 @@ fn c643_l1615_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_neg_add", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -10965,10 +8567,7 @@ fn c644_l1616_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_neg_add", &[Value::F32((0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -10976,10 +8575,7 @@ fn c645_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_neg_add", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -10987,10 +8583,7 @@ fn c646_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_neg_add", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -10998,10 +8591,7 @@ fn c647_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_neg_add", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -11009,10 +8599,7 @@ fn c648_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_neg_add", &[Value::F64((0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -11033,7 +8620,7 @@ fn test_module_65() {
     c648_l1621_action_invoke(&mut instance);
     c649_l1622_action_invoke(&mut instance);
 }
-fn create_module_66() -> Box<Instance> {
+fn create_module_66() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -11053,11 +8640,8 @@ fn create_module_66() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_66(instance: &mut Instance) {
@@ -11068,10 +8652,7 @@ fn start_module_66(instance: &mut Instance) {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_add_neg_neg", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -11079,10 +8660,7 @@ fn c651_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((-0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_add_neg_neg", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -11090,10 +8668,7 @@ fn c652_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_add_neg_neg", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -11101,10 +8676,7 @@ fn c653_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.no_fold_add_neg_neg", &[Value::F32((0.0f32)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -11112,10 +8684,7 @@ fn c654_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -11123,10 +8692,7 @@ fn c655_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -11134,10 +8700,7 @@ fn c656_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -11145,10 +8708,7 @@ fn c657_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.0f64))],
-    );
+    let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((0.0f64)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
@@ -11169,7 +8729,7 @@ fn test_module_66() {
     c657_l1641_action_invoke(&mut instance);
     c658_l1642_action_invoke(&mut instance);
 }
-fn create_module_67() -> Box<Instance> {
+fn create_module_67() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -11187,11 +8747,8 @@ fn create_module_67() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_67(instance: &mut Instance) {
@@ -11217,35 +8774,23 @@ fn c661_l1655_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)])
-        .unwrap()
-        .expect("Missing result in c662_l1656_assert_return_canonical_nan");
+    println!("Executing function {}", "c662_l1656_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_add_neg", &[Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c662_l1656_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)])
-        .unwrap()
-        .expect("Missing result in c663_l1657_assert_return_canonical_nan");
+    println!("Executing function {}", "c663_l1657_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_add_neg", &[Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c663_l1657_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -11267,35 +8812,23 @@ fn c665_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // 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)])
-        .unwrap()
-        .expect("Missing result in c666_l1661_assert_return_canonical_nan");
+    println!("Executing function {}", "c666_l1661_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_add_neg", &[Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c666_l1661_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)])
-        .unwrap()
-        .expect("Missing result in c667_l1662_assert_return_canonical_nan");
+    println!("Executing function {}", "c667_l1662_assert_return_canonical_nan");
+    let result = instance.call("f64.no_fold_add_neg", &[Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c667_l1662_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -11315,7 +8848,7 @@ fn test_module_67() {
     c666_l1661_assert_return_canonical_nan(&mut instance);
     c667_l1662_assert_return_canonical_nan(&mut instance);
 }
-fn create_module_68() -> Box<Instance> {
+fn create_module_68() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -11347,11 +8880,8 @@ fn create_module_68() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_68(instance: &mut Instance) {
@@ -11362,52 +8892,31 @@ fn start_module_68(instance: &mut Instance) {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-5133083000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-855513700000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-5133083000000000000000000000000.0f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.00000000000000000000007257036f32))))
-    );
+    let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-0.00000000000000000000001209506f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000007257036f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.000000000000000000000039856134f32))))
-    );
+    let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((0.000000000000000000000006642689f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000039856134f32)))));
     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))],
-    );
+    let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-0.0000000006147346f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000000036884074f32)))));
     result.map(|_| ())
 }
@@ -11415,24 +8924,15 @@ fn c672_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-7259148300000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-1209858100000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-7259148300000000000000000.0f32)))));
     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))],
-    );
+    let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((-351704490602771400000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-2110226943616628600000.0f64)))));
     result.map(|_| ())
 }
@@ -11464,18 +8964,8 @@ fn c677_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-258698385151173640000000000000000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((-43116397525195610000000000000000000000000000000000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-258698385151173640000000000000000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -11497,7 +8987,7 @@ fn test_module_68() {
     c677_l1689_action_invoke(&mut instance);
     c678_l1690_action_invoke(&mut instance);
 }
-fn create_module_69() -> Box<Instance> {
+fn create_module_69() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -11517,11 +9007,8 @@ fn create_module_69() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_69(instance: &mut Instance) {
@@ -11532,32 +9019,15 @@ fn start_module_69(instance: &mut Instance) {
 // 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)),
-            Value::F32((-0.000030265672f32)),
-            Value::F32((-1584.8682f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-12380309000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_fold_div_div", &[Value::F32((-593847530000000000000000.0f32)), Value::F32((-0.000030265672f32)), Value::F32((-1584.8682f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-12380309000000000000000000.0f32)))));
     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)),
-            Value::F32((2533429300000000000000000000000000.0f32)),
-            Value::F32((-0.00000000000000000000000000000000026844783f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_div_div", &[Value::F32((0.0000000000000000000015438962f32)), Value::F32((2533429300000000000000000000000000.0f32)), Value::F32((-0.00000000000000000000000000000000026844783f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -11565,14 +9035,7 @@ fn c681_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000029339205f32)),
-            Value::F32((76386374000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_div_div", &[Value::F32((13417423000000.0f32)), Value::F32((0.000000000000000000000000000000029339205f32)), Value::F32((76386374000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -11580,40 +9043,16 @@ fn c682_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-34220943000000000000000000000000000000.0f32)),
-            Value::F32((-0.00000000000016562324f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000019011327f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_div_div", &[Value::F32((-0.00010776529f32)), Value::F32((-34220943000000000000000000000000000000.0f32)), Value::F32((-0.00000000000016562324f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000019011327f32)))));
     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)),
-            Value::F32((96245350000000000.0f32)),
-            Value::F32((-41461545000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000032723f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_div_div", &[Value::F32((130582500000000.0f32)), Value::F32((96245350000000000.0f32)), Value::F32((-41461545000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000032723f32)))));
     result.map(|_| ())
 }
 
@@ -11653,12 +9092,7 @@ fn c688_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050233948816631796f64)), Value::F64((-0.0000000000000000000000000000000000000000028304570228221077f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.00000000000000000000000000000000000000000000006699534674970116f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000006699534674970116f64)))));
     result.map(|_| ())
 }
 
@@ -11680,7 +9114,7 @@ fn test_module_69() {
     c688_l1712_action_invoke(&mut instance);
     c689_l1713_action_invoke(&mut instance);
 }
-fn create_module_70() -> Box<Instance> {
+fn create_module_70() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64 f64) (result f64)))
@@ -11704,11 +9138,8 @@ fn create_module_70() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_70(instance: &mut Instance) {
@@ -11719,36 +9150,15 @@ fn start_module_70(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.0000000000000000000000000003897843f32)),
-            Value::F32((0.000000000000000000000000004847123f32)),
-            Value::F32((-25.357775f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.0000000000000000000000000000000013355855f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-0.0000000000000000000000000000000027234733f32)), Value::F32((0.0000000000000000000000000003897843f32)), Value::F32((0.000000000000000000000000004847123f32)), Value::F32((-25.357775f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000013355855f32)))));
     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)),
-            Value::F32((38340910.0f32)),
-            Value::F32((0.000014973162f32)),
-            Value::F32((0.19213825f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-5372844000000000000000000000000.0f32)), Value::F32((38340910.0f32)), Value::F32((0.000014973162f32)), Value::F32((0.19213825f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-10920475000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -11756,15 +9166,7 @@ fn c692_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1092920200000.0f32)),
-            Value::F32((-869606000.0f32)),
-            Value::F32((-1201.206f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-16085042000.0f32)), Value::F32((-1092920200000.0f32)), Value::F32((-869606000.0f32)), Value::F32((-1201.206f32))]);
     assert_eq!(result, Ok(Some(Value::F32((10654.639f32)))));
     result.map(|_| ())
 }
@@ -11772,15 +9174,7 @@ fn c693_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00000000010768114f32)),
-            Value::F32((0.000018576271f32)),
-            Value::F32((492686200000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-1271223140000000000000000000000000.0f32)), Value::F32((0.00000000010768114f32)), Value::F32((0.000018576271f32)), Value::F32((492686200000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -11788,15 +9182,7 @@ fn c694_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000065046285f32)),
-            Value::F32((0.00000000000000000000000000068167684f32)),
-            Value::F32((0.000000000022892627f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((0.00000000000000013783864f32)), Value::F32((-0.000000000000000000065046285f32)), Value::F32((0.00000000000000000000000000068167684f32)), Value::F32((0.000000000022892627f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.000000000000063100295f32)))));
     result.map(|_| ())
 }
@@ -11859,7 +9245,7 @@ fn test_module_70() {
     c699_l1736_action_invoke(&mut instance);
     c700_l1737_action_invoke(&mut instance);
 }
-fn create_module_71() -> Box<Instance> {
+fn create_module_71() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -11883,11 +9269,8 @@ fn create_module_71() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_71(instance: &mut Instance) {
@@ -11898,74 +9281,31 @@ fn start_module_71(instance: &mut Instance) {
 // 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)),
-            Value::F32((-0.040118184f32)),
-            Value::F32((-136292990000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.0000000000000000000000000000000000027685121f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_add_divs", &[Value::F32((377.3689f32)), Value::F32((-0.040118184f32)), Value::F32((-136292990000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000000000000027685121f32)))));
     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)),
-            Value::F32((-0.0000000000000033970288f32)),
-            Value::F32((-170996700000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000019867115f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.00000000000000000018234023f32)), Value::F32((-0.0000000000000033970288f32)), Value::F32((-170996700000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000019867115f32)))));
     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)),
-            Value::F32((0.00000000000000000006414099f32)),
-            Value::F32((-541989070000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000036296997f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.000000000000019672638f32)), Value::F32((0.00000000000000000006414099f32)), Value::F32((-541989070000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000036296997f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000003848228f32)),
-            Value::F32((-345237200000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.0000000000000000000000000000004038506f32)), Value::F32((0.000000000000000000000000000003848228f32)), Value::F32((-345237200000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -11973,20 +9313,8 @@ fn c705_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.20703124f32)),
-            Value::F32((0.00000000000000000000000000000000000013509784f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (1540547700000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.no_fold_add_divs", &[Value::F32((0.0010934415f32)), Value::F32((0.20703124f32)), Value::F32((0.00000000000000000000000000000000000013509784f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((1540547700000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -12048,7 +9376,7 @@ fn test_module_71() {
     c710_l1758_action_invoke(&mut instance);
     c711_l1759_action_invoke(&mut instance);
 }
-fn create_module_72() -> Box<Instance> {
+fn create_module_72() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -12066,11 +9394,8 @@ fn create_module_72() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_72(instance: &mut Instance) {
@@ -12081,52 +9406,31 @@ fn start_module_72(instance: &mut Instance) {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.00000000000000000001846001f32))))
-    );
+    let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000001846f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000001846001f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.00000000000000000000017952678f32))))
-    );
+    let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000000017907473f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000017952678f32)))));
     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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.000000000000000000000791442f32))))
-    );
+    let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000000079120785f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000791442f32)))));
     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))],
-    );
+    let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((0.000000000000000000000000018012938f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -12134,10 +9438,7 @@ fn c716_l1774_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((610501970000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -12200,7 +9501,7 @@ fn test_module_72() {
     c721_l1780_action_invoke(&mut instance);
     c722_l1781_action_invoke(&mut instance);
 }
-fn create_module_73() -> Box<Instance> {
+fn create_module_73() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -12220,11 +9521,8 @@ fn create_module_73() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_73(instance: &mut Instance) {
@@ -12234,54 +9532,27 @@ fn start_module_73(instance: &mut Instance) {
 
 // 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)),
-                Value::F32((-0.00000000000000000000000011867334f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c724_l1793_assert_return_canonical_nan");
+    println!("Executing function {}", "c724_l1793_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.000000000000000000000000000000000000043885047f32)), Value::F32((-0.00000000000000000000000011867334f32))]).unwrap().expect("Missing result in c724_l1793_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)),
-            Value::F32((0.00000000041320675f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.00000000000000000032374932f32))))
-    );
+    let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.00000000000000000000000000025365908f32)), Value::F32((0.00000000041320675f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000032374932f32)))));
     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)),
-            Value::F32((97.249115f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.0000000000000000000000000042144832f32)), Value::F32((97.249115f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000000064019905f32)))));
     result.map(|_| ())
 }
@@ -12289,13 +9560,7 @@ fn c726_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.002944908f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((3724076300000000000000000000000.0f32)), Value::F32((0.002944908f32))]);
     assert_eq!(result, Ok(Some(Value::F32((104723750000000.0f32)))));
     result.map(|_| ())
 }
@@ -12303,28 +9568,19 @@ fn c727_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.002111261f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.00000000000000001866056f32)), Value::F32((0.002111261f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000019848755f32)))));
     result.map(|_| ())
 }
 
 // Line 1799
 fn c729_l1799_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c729_l1799_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c729_l1799_assert_return_canonical_nan");
     let result = instance.call("f64.no_fold_mul_sqrts", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012742064369772862f64)), Value::F64((-0.006829962938197246f64))]).unwrap().expect("Missing result in c729_l1799_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -12378,7 +9634,7 @@ fn test_module_73() {
     c732_l1802_action_invoke(&mut instance);
     c733_l1803_action_invoke(&mut instance);
 }
-fn create_module_74() -> Box<Instance> {
+fn create_module_74() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -12398,11 +9654,8 @@ fn create_module_74() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_74(instance: &mut Instance) {
@@ -12412,34 +9665,19 @@ fn start_module_74(instance: &mut Instance) {
 
 // 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)),
-                Value::F32((-0.000000000000000006443773f32)),
-            ],
-        )
-        .unwrap()
-        .expect("Missing result in c735_l1815_assert_return_canonical_nan");
+    println!("Executing function {}", "c735_l1815_assert_return_canonical_nan");
+    let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((-58545012.0f32)), Value::F32((-0.000000000000000006443773f32))]).unwrap().expect("Missing result in c735_l1815_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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)), Value::F32((209778930.0f32))],
-    );
+    let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((7407384000.0f32)), Value::F32((209778930.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((5.9422584f32)))));
     result.map(|_| ())
 }
@@ -12447,30 +9685,15 @@ fn c736_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((54692.9f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000000050165927f32))))
-    );
+    let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((0.0000000000000000000000000000000000013764126f32)), Value::F32((54692.9f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000050165927f32)))));
     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)),
-            Value::F32((0.0000000012643552f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((979288960000000000.0f32)), Value::F32((0.0000000012643552f32))]);
     assert_eq!(result, Ok(Some(Value::F32((27830490000000.0f32)))));
     result.map(|_| ())
 }
@@ -12478,28 +9701,19 @@ fn c738_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00000000000000000000000000000017928174f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((0.00000000000000000000000000000000029141283f32)), Value::F32((0.00000000000000000000000000000017928174f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.04031682f32)))));
     result.map(|_| ())
 }
 
 // Line 1821
 fn c740_l1821_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c740_l1821_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c740_l1821_assert_return_canonical_nan");
     let result = instance.call("f64.no_fold_div_sqrts", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012206137319883022f64)), Value::F64((-0.000000000000000000000000000000000000000000000000000000008209583449676083f64))]).unwrap().expect("Missing result in c740_l1821_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => unimplemented!()
     })
 }
 
@@ -12553,7 +9767,7 @@ fn test_module_74() {
     c743_l1824_action_invoke(&mut instance);
     c744_l1825_action_invoke(&mut instance);
 }
-fn create_module_75() -> Box<Instance> {
+fn create_module_75() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -12575,11 +9789,8 @@ fn create_module_75() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_75(instance: &mut Instance) {
@@ -12590,13 +9801,7 @@ fn start_module_75(instance: &mut Instance) {
 // 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)),
-            Value::F32((8677282000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-4728556800000000000000000.0f32)), Value::F32((8677282000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY))));
     result.map(|_| ())
 }
@@ -12604,13 +9809,7 @@ fn c746_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000009805153f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-0.0000000000000000000000000000000000011776882f32)), Value::F32((0.000000000000000000000000000009805153f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -12618,30 +9817,15 @@ fn c747_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000003323171f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((14167568000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((816717060.0f32)), Value::F32((0.000000000000000000000000000000000000003323171f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((14167568000000000000000000000.0f32)))));
     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)),
-            Value::F32((8637067000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-11932267000000.0f32)), Value::F32((8637067000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00012839255f32)))));
     result.map(|_| ())
 }
@@ -12649,10 +9833,7 @@ fn c749_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((134.33022f32))],
-    );
+    let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-401.0235f32)), Value::F32((134.33022f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-34.600548f32)))));
     result.map(|_| ())
 }
@@ -12715,7 +9896,7 @@ fn test_module_75() {
     c754_l1846_action_invoke(&mut instance);
     c755_l1847_action_invoke(&mut instance);
 }
-fn create_module_76() -> Box<Instance> {
+fn create_module_76() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -12735,11 +9916,8 @@ fn create_module_76() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_76(instance: &mut Instance) {
@@ -12750,20 +9928,8 @@ fn start_module_76(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.00000011920929f32)),
-            Value::F32((8388608.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("f32.no_flush_intermediate_subnormal", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.00000011920929f32)), Value::F32((8388608.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -12785,7 +9951,7 @@ fn test_module_76() {
     c757_l1860_action_invoke(&mut instance);
     c758_l1861_action_invoke(&mut instance);
 }
-fn create_module_77() -> Box<Instance> {
+fn create_module_77() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result i32)))
       (type (;1;) (func (param f64 f64) (result i32)))
@@ -12840,11 +10006,8 @@ fn create_module_77() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_77(instance: &mut Instance) {
@@ -12855,10 +10018,7 @@ fn start_module_77(instance: &mut Instance) {
 // 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), Value::F32((3.0f32))],
-    );
+    let result = instance.call("f32.recoding_eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12866,10 +10026,7 @@ fn c760_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((3.0f32))],
-    );
+    let result = instance.call("f32.recoding_le", &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12877,10 +10034,7 @@ fn c761_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F32((3.0f32))],
-    );
+    let result = instance.call("f32.recoding_lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12888,10 +10042,7 @@ fn c762_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("f32.recoding_eq", &[Value::F32((0.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12899,10 +10050,7 @@ fn c763_l1893_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("f32.recoding_le", &[Value::F32((0.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12910,10 +10058,7 @@ fn c764_l1894_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("f32.recoding_lt", &[Value::F32((0.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12921,10 +10066,7 @@ fn c765_l1895_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((3.0f64))],
-    );
+    let result = instance.call("f64.recoding_eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12932,10 +10074,7 @@ fn c766_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((3.0f64))],
-    );
+    let result = instance.call("f64.recoding_le", &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12943,10 +10082,7 @@ fn c767_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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), Value::F64((3.0f64))],
-    );
+    let result = instance.call("f64.recoding_lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12954,10 +10090,7 @@ fn c768_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("f64.recoding_eq", &[Value::F64((0.0f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12965,10 +10098,7 @@ fn c769_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("f64.recoding_le", &[Value::F64((0.0f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -12976,10 +10106,7 @@ fn c770_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("f64.recoding_lt", &[Value::F64((0.0f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -12987,19 +10114,8 @@ fn c771_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1221.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.0000000000000000000000000000000000002913312f32)
-        )))
-    );
+    let result = instance.call("recoding_demote", &[Value::F64((0.00000000000000000000000000000000000000023860049081905093f64)), Value::F32((1221.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000002913312f32)))));
     result.map(|_| ())
 }
 
@@ -13024,7 +10140,7 @@ fn test_module_77() {
     c771_l1903_action_invoke(&mut instance);
     c772_l1905_action_invoke(&mut instance);
 }
-fn create_module_78() -> Box<Instance> {
+fn create_module_78() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result i32)))
       (type (;1;) (func (param f64 f64 f64) (result i32)))
@@ -13044,11 +10160,8 @@ fn create_module_78() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_78(instance: &mut Instance) {
@@ -13059,14 +10172,7 @@ fn start_module_78(instance: &mut Instance) {
 // 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)),
-            Value::F32((7.0f32)),
-            Value::F32((0.42857143f32)),
-        ],
-    );
+    let result = instance.call("f32.no_extended_precision_div", &[Value::F32((3.0f32)), Value::F32((7.0f32)), Value::F32((0.42857143f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13074,14 +10180,7 @@ fn c774_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((7.0f64)),
-            Value::F64((0.42857142857142855f64)),
-        ],
-    );
+    let result = instance.call("f64.no_extended_precision_div", &[Value::F64((3.0f64)), Value::F64((7.0f64)), Value::F64((0.42857142857142855f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13096,7 +10195,7 @@ fn test_module_78() {
     c774_l1918_action_invoke(&mut instance);
     c775_l1919_action_invoke(&mut instance);
 }
-fn create_module_79() -> Box<Instance> {
+fn create_module_79() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -13120,11 +10219,8 @@ fn create_module_79() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_79(instance: &mut Instance) {
@@ -13158,7 +10254,7 @@ fn test_module_79() {
     c777_l1934_action_invoke(&mut instance);
     c778_l1935_action_invoke(&mut instance);
 }
-fn create_module_80() -> Box<Instance> {
+fn create_module_80() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f32 f32 f32 f32) (result f32)))
@@ -13256,11 +10352,8 @@ fn create_module_80() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_80(instance: &mut Instance) {
@@ -13279,15 +10372,7 @@ fn c780_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((5.0f32)),
-            Value::F32((3.1415927f32)),
-            Value::F32((7.0f32)),
-        ],
-    );
+    let result = instance.call("f32.xkcd_sqrt_2", &[Value::F32((3.0f32)), Value::F32((5.0f32)), Value::F32((3.1415927f32)), Value::F32((7.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.4142201f32)))));
     result.map(|_| ())
 }
@@ -13303,14 +10388,7 @@ fn c782_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((2.7182817f32)),
-            Value::F32((3.1415927f32)),
-        ],
-    );
+    let result = instance.call("f32.xkcd_sqrt_3", &[Value::F32((2.0f32)), Value::F32((2.7182817f32)), Value::F32((3.1415927f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.7305119f32)))));
     result.map(|_| ())
 }
@@ -13326,14 +10404,7 @@ fn c784_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((2.7182817f32)),
-            Value::F32((3.0f32)),
-        ],
-    );
+    let result = instance.call("f32.xkcd_sqrt_5", &[Value::F32((2.0f32)), Value::F32((2.7182817f32)), Value::F32((3.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2.2357588f32)))));
     result.map(|_| ())
 }
@@ -13341,15 +10412,7 @@ fn c785_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((4.0f32)),
-            Value::F32((3.1415927f32)),
-            Value::F32((24.0f32)),
-        ],
-    );
+    let result = instance.call("f32.xkcd_better_sqrt_5", &[Value::F32((13.0f32)), Value::F32((4.0f32)), Value::F32((3.1415927f32)), Value::F32((24.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2.236068f32)))));
     result.map(|_| ())
 }
@@ -13365,15 +10428,7 @@ fn c787_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((5.0f64)),
-            Value::F64((3.141592653589793f64)),
-            Value::F64((7.0f64)),
-        ],
-    );
+    let result = instance.call("f64.xkcd_sqrt_2", &[Value::F64((3.0f64)), Value::F64((5.0f64)), Value::F64((3.141592653589793f64)), Value::F64((7.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.4142200580539208f64)))));
     result.map(|_| ())
 }
@@ -13389,14 +10444,7 @@ fn c789_l1982_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((2.718281828459045f64)),
-            Value::F64((3.141592653589793f64)),
-        ],
-    );
+    let result = instance.call("f64.xkcd_sqrt_3", &[Value::F64((2.0f64)), Value::F64((2.718281828459045f64)), Value::F64((3.141592653589793f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.7305119588645301f64)))));
     result.map(|_| ())
 }
@@ -13412,14 +10460,7 @@ fn c791_l1984_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((2.718281828459045f64)),
-            Value::F64((3.0f64)),
-        ],
-    );
+    let result = instance.call("f64.xkcd_sqrt_5", &[Value::F64((2.0f64)), Value::F64((2.718281828459045f64)), Value::F64((3.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((2.2357588823428847f64)))));
     result.map(|_| ())
 }
@@ -13427,15 +10468,7 @@ fn c792_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((4.0f64)),
-            Value::F64((3.141592653589793f64)),
-            Value::F64((24.0f64)),
-        ],
-    );
+    let result = instance.call("f64.xkcd_better_sqrt_5", &[Value::F64((13.0f64)), Value::F64((4.0f64)), Value::F64((3.141592653589793f64)), Value::F64((24.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((2.2360678094452893f64)))));
     result.map(|_| ())
 }
@@ -13462,7 +10495,7 @@ fn test_module_80() {
     c792_l1985_action_invoke(&mut instance);
     c793_l1986_action_invoke(&mut instance);
 }
-fn create_module_81() -> Box<Instance> {
+fn create_module_81() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -13534,11 +10567,8 @@ fn create_module_81() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_81(instance: &mut Instance) {
@@ -13549,10 +10579,7 @@ fn start_module_81(instance: &mut Instance) {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("f32.compute_radix", &[Value::F32((1.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2.0f32)))));
     result.map(|_| ())
 }
@@ -13560,10 +10587,7 @@ fn c795_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("f64.compute_radix", &[Value::F64((1.0f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((2.0f64)))));
     result.map(|_| ())
 }
@@ -13578,7 +10602,7 @@ fn test_module_81() {
     c795_l2069_action_invoke(&mut instance);
     c796_l2070_action_invoke(&mut instance);
 }
-fn create_module_82() -> Box<Instance> {
+fn create_module_82() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -13602,11 +10626,8 @@ fn create_module_82() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_82(instance: &mut Instance) {
@@ -13617,10 +10638,7 @@ fn start_module_82(instance: &mut Instance) {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("f32.no_fold_sub1_mul_add", &[Value::F32((0.00000000023283064f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -13628,13 +10646,7 @@ fn c798_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_sub1_mul_add", &[Value::F64((0.00000000000000000005421010862427522f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -13649,7 +10661,7 @@ fn test_module_82() {
     c798_l2083_action_invoke(&mut instance);
     c799_l2084_action_invoke(&mut instance);
 }
-fn create_module_83() -> Box<Instance> {
+fn create_module_83() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result i32)))
       (type (;1;) (func (param f64 f64 f64) (result i32)))
@@ -13691,11 +10703,8 @@ fn create_module_83() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_83(instance: &mut Instance) {
@@ -13706,14 +10715,7 @@ fn start_module_83(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.0f32)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("f32.no_fold_add_le_monotonicity", &[Value::F32((0.0f32)), Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13721,14 +10723,7 @@ fn c801_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F32(f32::NEG_INFINITY),
-            Value::F32(f32::INFINITY),
-        ],
-    );
+    let result = instance.call("f32.no_fold_add_le_monotonicity", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13736,14 +10731,7 @@ fn c802_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_fold_add_le_monotonicity", &[Value::F64((0.0f64)), Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13751,14 +10739,7 @@ fn c803_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            Value::F64(f64::NEG_INFINITY),
-            Value::F64(f64::INFINITY),
-        ],
-    );
+    let result = instance.call("f64.no_fold_add_le_monotonicity", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -13775,7 +10756,7 @@ fn test_module_83() {
     c803_l2105_action_invoke(&mut instance);
     c804_l2106_action_invoke(&mut instance);
 }
-fn create_module_84() -> Box<Instance> {
+fn create_module_84() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result i32)))
       (type (;1;) (func (param f64 f64) (result i32)))
@@ -13829,11 +10810,8 @@ fn create_module_84() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_84(instance: &mut Instance) {
@@ -13844,10 +10822,7 @@ fn start_module_84(instance: &mut Instance) {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.not_lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13855,10 +10830,7 @@ fn c806_l2136_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.not_le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13866,10 +10838,7 @@ fn c807_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.not_gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13877,10 +10846,7 @@ fn c808_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.0f32))],
-    );
+    let result = instance.call("f32.not_ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13888,13 +10854,7 @@ fn c809_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.not_lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13902,13 +10862,7 @@ fn c810_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.not_le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13916,13 +10870,7 @@ fn c811_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.not_gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13930,13 +10878,7 @@ fn c812_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.0f64)),
-        ],
-    );
+    let result = instance.call("f64.not_ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]);
     assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
     result.map(|_| ())
 }
@@ -13957,7 +10899,7 @@ fn test_module_84() {
     c812_l2142_action_invoke(&mut instance);
     c813_l2143_action_invoke(&mut instance);
 }
-fn create_module_85() -> Box<Instance> {
+fn create_module_85() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f32)))
       (type (;1;) (func (result f64)))
@@ -13985,11 +10927,8 @@ fn create_module_85() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_85(instance: &mut Instance) {
@@ -14009,10 +10948,7 @@ fn c815_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))));
     result.map(|_| ())
 }
 
@@ -14026,7 +10962,7 @@ fn test_module_85() {
     c815_l2157_action_invoke(&mut instance);
     c816_l2158_action_invoke(&mut instance);
 }
-fn create_module_86() -> Box<Instance> {
+fn create_module_86() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f32)))
       (type (;1;) (func (result f64)))
@@ -14068,11 +11004,8 @@ fn create_module_86() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_86(instance: &mut Instance) {
@@ -14092,10 +11025,7 @@ fn c818_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))));
     result.map(|_| ())
 }
 
@@ -14109,7 +11039,7 @@ fn test_module_86() {
     c818_l2212_action_invoke(&mut instance);
     c819_l2213_action_invoke(&mut instance);
 }
-fn create_module_87() -> Box<Instance> {
+fn create_module_87() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result i32)))
       (type (;1;) (func (param f64 f64) (result i32)))
@@ -14187,11 +11117,8 @@ fn create_module_87() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_87(instance: &mut Instance) {
@@ -14202,10 +11129,7 @@ fn start_module_87(instance: &mut Instance) {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_trichotomy_lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14213,10 +11137,7 @@ fn c821_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_trichotomy_le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14224,10 +11145,7 @@ fn c822_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_trichotomy_gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14235,10 +11153,7 @@ fn c823_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32(f32::from_bits(2143289344))],
-    );
+    let result = instance.call("f32.no_trichotomy_ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14246,13 +11161,7 @@ fn c824_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_trichotomy_lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14260,13 +11169,7 @@ fn c825_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_trichotomy_le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14274,13 +11177,7 @@ fn c826_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_trichotomy_gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14288,13 +11185,7 @@ fn c827_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.no_trichotomy_ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -14315,7 +11206,7 @@ fn test_module_87() {
     c827_l2244_action_invoke(&mut instance);
     c828_l2245_action_invoke(&mut instance);
 }
-fn create_module_88() -> Box<Instance> {
+fn create_module_88() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func (param i32) (result i32)))
@@ -14492,11 +11383,8 @@ fn create_module_88() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_88(instance: &mut Instance) {
@@ -14507,10 +11395,7 @@ fn start_module_88(instance: &mut Instance) {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14518,10 +11403,7 @@ fn c830_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14529,10 +11411,7 @@ fn c831_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14540,10 +11419,7 @@ fn c832_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14551,10 +11427,7 @@ fn c833_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14562,10 +11435,7 @@ fn c834_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14573,10 +11443,7 @@ fn c835_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14584,10 +11451,7 @@ fn c836_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14595,10 +11459,7 @@ fn c837_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14606,10 +11467,7 @@ fn c838_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14617,13 +11475,7 @@ fn c839_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -14631,10 +11483,7 @@ fn c840_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14642,13 +11491,7 @@ fn c841_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -14656,13 +11499,7 @@ fn c842_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -14670,13 +11507,7 @@ fn c843_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -14684,13 +11515,7 @@ fn c844_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -14698,10 +11523,7 @@ fn c845_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14709,10 +11531,7 @@ fn c846_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14720,10 +11539,7 @@ fn c847_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14731,10 +11547,7 @@ fn c848_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14790,10 +11603,7 @@ fn c855_l2354_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14801,10 +11611,7 @@ fn c856_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14812,10 +11619,7 @@ fn c857_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14823,10 +11627,7 @@ fn c858_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14834,10 +11635,7 @@ fn c859_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14845,10 +11643,7 @@ fn c860_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -14902,7 +11697,7 @@ fn test_module_88() {
     c861_l2360_action_invoke(&mut instance);
     c862_l2361_action_invoke(&mut instance);
 }
-fn create_module_89() -> Box<Instance> {
+fn create_module_89() -> Instance {
     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)
@@ -14941,11 +11736,8 @@ fn create_module_89() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_89(instance: &mut Instance) {
@@ -14956,19 +11748,7 @@ fn start_module_89(instance: &mut Instance) {
 // 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)),
-            Value::F64((1.0f64)),
-            Value::F64((-1.0f64)),
-            Value::F64((80000000.0f64)),
-            Value::F64((40000000.0f64)),
-            Value::F64((1.0f64)),
-            Value::F64((-1.0f64)),
-            Value::F64((-16000000.0f64)),
-        ],
-    );
+    let result = instance.call("dot_product_example", &[Value::F64((32000000.0f64)), Value::F64((1.0f64)), Value::F64((-1.0f64)), Value::F64((80000000.0f64)), Value::F64((40000000.0f64)), Value::F64((1.0f64)), Value::F64((-1.0f64)), Value::F64((-16000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((2.0f64)))));
     result.map(|_| ())
 }
@@ -14976,19 +11756,7 @@ fn c864_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-            Value::F64((-1.0f64)),
-            Value::F64((80000000.0f64)),
-            Value::F64((40000000.0f64)),
-            Value::F64((1.0f64)),
-            Value::F64((-1.0f64)),
-            Value::F64((-16000000.0f64)),
-        ],
-    );
+    let result = instance.call("with_binary_sum_collapse", &[Value::F64((32000000.0f64)), Value::F64((1.0f64)), Value::F64((-1.0f64)), Value::F64((80000000.0f64)), Value::F64((40000000.0f64)), Value::F64((1.0f64)), Value::F64((-1.0f64)), Value::F64((-16000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((2.0f64)))));
     result.map(|_| ())
 }
@@ -15003,7 +11771,7 @@ fn test_module_89() {
     c864_l2389_action_invoke(&mut instance);
     c865_l2393_action_invoke(&mut instance);
 }
-fn create_module_90() -> Box<Instance> {
+fn create_module_90() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -15029,11 +11797,8 @@ fn create_module_90() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_90(instance: &mut Instance) {
@@ -15044,10 +11809,7 @@ fn start_module_90(instance: &mut Instance) {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("f32.contract2fma", &[Value::F32((1.0f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -15055,10 +11817,7 @@ fn c867_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.1f32))],
-    );
+    let result = instance.call("f32.contract2fma", &[Value::F32((1.1f32)), Value::F32((1.1f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -15066,10 +11825,7 @@ fn c868_l2412_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.1999999f32))],
-    );
+    let result = instance.call("f32.contract2fma", &[Value::F32((1.1999999f32)), Value::F32((1.1999999f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -15077,10 +11833,7 @@ fn c869_l2413_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0f64))],
-    );
+    let result = instance.call("f64.contract2fma", &[Value::F64((1.0f64)), Value::F64((1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -15088,10 +11841,7 @@ fn c870_l2414_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.1f64))],
-    );
+    let result = instance.call("f64.contract2fma", &[Value::F64((1.1f64)), Value::F64((1.1f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -15099,10 +11849,7 @@ fn c871_l2415_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.2f64))],
-    );
+    let result = instance.call("f64.contract2fma", &[Value::F64((1.2f64)), Value::F64((1.2f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0f64)))));
     result.map(|_| ())
 }
@@ -15121,7 +11868,7 @@ fn test_module_90() {
     c871_l2415_action_invoke(&mut instance);
     c872_l2416_action_invoke(&mut instance);
 }
-fn create_module_91() -> Box<Instance> {
+fn create_module_91() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -15141,11 +11888,8 @@ fn create_module_91() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_91(instance: &mut Instance) {
@@ -15156,14 +11900,7 @@ fn start_module_91(instance: &mut Instance) {
 // 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)),
-            Value::F32((100000.0f32)),
-            Value::F32((0.0009f32)),
-        ],
-    );
+    let result = instance.call("f32.division_by_small_number", &[Value::F32((112000000.0f32)), Value::F32((100000.0f32)), Value::F32((0.0009f32))]);
     assert_eq!(result, Ok(Some(Value::F32((888888.0f32)))));
     result.map(|_| ())
 }
@@ -15171,14 +11908,7 @@ fn c874_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((100000.0f64)),
-            Value::F64((0.0009f64)),
-        ],
-    );
+    let result = instance.call("f64.division_by_small_number", &[Value::F64((112000000.0f64)), Value::F64((100000.0f64)), Value::F64((0.0009f64))]);
     assert_eq!(result, Ok(Some(Value::F64((888888.8888888806f64)))));
     result.map(|_| ())
 }
@@ -15193,7 +11923,7 @@ fn test_module_91() {
     c874_l2430_action_invoke(&mut instance);
     c875_l2431_action_invoke(&mut instance);
 }
-fn create_module_92() -> Box<Instance> {
+fn create_module_92() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64 f64) (result f64)))
@@ -15215,11 +11945,8 @@ fn create_module_92() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_92(instance: &mut Instance) {
@@ -15230,14 +11957,7 @@ fn start_module_92(instance: &mut Instance) {
 // 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)),
-            Value::F32((1.0f32)),
-            Value::F32((5.0f32)),
-        ],
-    );
+    let result = instance.call("f32.golden_ratio", &[Value::F32((0.5f32)), Value::F32((1.0f32)), Value::F32((5.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.618034f32)))));
     result.map(|_| ())
 }
@@ -15245,14 +11965,7 @@ fn c877_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-            Value::F64((5.0f64)),
-        ],
-    );
+    let result = instance.call("f64.golden_ratio", &[Value::F64((0.5f64)), Value::F64((1.0f64)), Value::F64((5.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.618033988749895f64)))));
     result.map(|_| ())
 }
@@ -15267,7 +11980,7 @@ fn test_module_92() {
     c877_l2443_action_invoke(&mut instance);
     c878_l2444_action_invoke(&mut instance);
 }
-fn create_module_93() -> Box<Instance> {
+fn create_module_93() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32) (result f32)))
       (type (;1;) (func (param f64) (result f64)))
@@ -15297,11 +12010,8 @@ fn create_module_93() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_93(instance: &mut Instance) {
@@ -15425,7 +12135,7 @@ fn test_module_93() {
     c890_l2472_action_invoke(&mut instance);
     c891_l2473_action_invoke(&mut instance);
 }
-fn create_module_94() -> Box<Instance> {
+fn create_module_94() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f64 f64) (result i32)))
       (func (;0;) (type 0) (param f64 f64) (result i32)
@@ -15437,11 +12147,8 @@ fn create_module_94() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_94(instance: &mut Instance) {
@@ -15466,7 +12173,7 @@ fn test_module_94() {
     start_module_94(&mut instance);
     c893_l2483_action_invoke(&mut instance);
 }
-fn create_module_95() -> Box<Instance> {
+fn create_module_95() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result f64)))
       (func (;0;) (type 0) (param i32) (result f64)
@@ -15533,11 +12240,8 @@ fn create_module_95() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_95(instance: &mut Instance) {
@@ -15571,7 +12275,7 @@ fn test_module_95() {
     c895_l2553_action_invoke(&mut instance);
     c896_l2554_action_invoke(&mut instance);
 }
-fn create_module_96() -> Box<Instance> {
+fn create_module_96() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f64 f64) (result f64)))
@@ -15597,11 +12301,8 @@ fn create_module_96() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_96(instance: &mut Instance) {
@@ -15612,10 +12313,7 @@ fn start_module_96(instance: &mut Instance) {
 // 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)), Value::F32((-1.0f32))],
-    );
+    let result = instance.call("f32.no_fold_conditional_inc", &[Value::F32((-0.0f32)), Value::F32((-1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0f32)))));
     result.map(|_| ())
 }
@@ -15623,10 +12321,7 @@ fn c898_l2569_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((-1.0f64))],
-    );
+    let result = instance.call("f64.no_fold_conditional_inc", &[Value::F64((-0.0f64)), Value::F64((-1.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.0f64)))));
     result.map(|_| ())
 }
diff --git a/lib/runtime/tests/spectests/float_literals.rs b/lib/runtime/tests/spectests/float_literals.rs
index 1643055fe..f609c1965 100644
--- a/lib/runtime/tests/spectests/float_literals.rs
+++ b/lib/runtime/tests/spectests/float_literals.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func (result i64)))
@@ -331,11 +335,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -875,10 +876,7 @@ fn c66_l172_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))))
-    );
+    assert_eq!(result, Ok(Some(Value::F32((12200012000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -958,10 +956,7 @@ fn c76_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((12200011354000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -1095,7 +1090,7 @@ fn test_module_1() {
     c81_l188_action_invoke(&mut instance);
     c82_l189_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f64)))
       (func (;0;) (type 0) (result f64)
@@ -1103,11 +1098,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -1126,1065 +1118,609 @@ fn c84_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/float_memory.rs b/lib/runtime/tests/spectests/float_memory.rs
index 5a62a83c4..759e19a4e 100644
--- a/lib/runtime/tests/spectests/float_memory.rs
+++ b/lib/runtime/tests/spectests/float_memory.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 5
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f32)))
       (type (;1;) (func (result i32)))
@@ -47,11 +51,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -72,15 +73,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -88,7 +86,7 @@ fn c2_l16_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c3_l17_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c3_l17_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -112,7 +110,7 @@ fn c5_l19_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -129,15 +127,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -145,7 +140,7 @@ fn c8_l22_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c9_l23_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c9_l23_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -169,7 +164,7 @@ fn c11_l25_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -186,15 +181,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -220,7 +212,7 @@ fn test_module_1() {
     c13_l27_action_invoke(&mut instance);
     c14_l28_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f64)))
       (type (;1;) (func (result i64)))
@@ -252,11 +244,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -277,15 +266,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -293,7 +279,7 @@ fn c17_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c18_l42_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c18_l42_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -317,7 +303,7 @@ fn c20_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -334,15 +320,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -350,7 +333,7 @@ fn c23_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c24_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c24_l48_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -374,7 +357,7 @@ fn c26_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -391,15 +374,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -425,7 +405,7 @@ fn test_module_2() {
     c28_l52_action_invoke(&mut instance);
     c29_l53_action_invoke(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f32)))
       (type (;1;) (func (result i32)))
@@ -457,11 +437,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -482,15 +459,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -498,7 +472,7 @@ fn c32_l68_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c33_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c33_l69_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -522,7 +496,7 @@ fn c35_l71_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -539,15 +513,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -555,7 +526,7 @@ fn c38_l74_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c39_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c39_l75_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -579,7 +550,7 @@ fn c41_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -596,15 +567,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -630,7 +598,7 @@ fn test_module_3() {
     c43_l79_action_invoke(&mut instance);
     c44_l80_action_invoke(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f64)))
       (type (;1;) (func (result i64)))
@@ -662,11 +630,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -687,15 +652,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -703,7 +665,7 @@ fn c47_l93_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c48_l94_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c48_l94_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -727,7 +689,7 @@ fn c50_l96_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -744,15 +706,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -760,7 +719,7 @@ fn c53_l99_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c54_l100_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c54_l100_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -784,7 +743,7 @@ fn c56_l102_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -801,15 +760,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -835,7 +791,7 @@ fn test_module_4() {
     c58_l104_action_invoke(&mut instance);
     c59_l105_action_invoke(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f32)))
       (type (;1;) (func (result i32)))
@@ -867,11 +823,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -892,15 +845,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -908,7 +858,7 @@ fn c62_l120_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c63_l121_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c63_l121_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -932,7 +882,7 @@ fn c65_l123_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -949,15 +899,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -965,7 +912,7 @@ fn c68_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c69_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c69_l127_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -989,7 +936,7 @@ fn c71_l129_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -1006,15 +953,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -1040,7 +984,7 @@ fn test_module_5() {
     c73_l131_action_invoke(&mut instance);
     c74_l132_action_invoke(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result f64)))
       (type (;1;) (func (result i64)))
@@ -1072,11 +1016,8 @@ fn create_module_6() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -1097,15 +1038,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -1113,7 +1051,7 @@ fn c77_l145_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c78_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c78_l146_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -1137,7 +1075,7 @@ fn c80_l148_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -1154,15 +1092,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
@@ -1170,7 +1105,7 @@ fn c83_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c84_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c84_l152_action_invoke");
     let result = instance.call("reset", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -1194,7 +1129,7 @@ fn c86_l154_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -1211,15 +1146,12 @@ 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);
-    }
+                                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(|_| ())
 }
 
diff --git a/lib/runtime/tests/spectests/float_misc.rs b/lib/runtime/tests/spectests/float_misc.rs
index 5d0ef6622..a980e4a40 100644
--- a/lib/runtime/tests/spectests/float_misc.rs
+++ b/lib/runtime/tests/spectests/float_misc.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 17
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32 f32) (result f32)))
       (type (;1;) (func (param f32) (result f32)))
@@ -149,11 +153,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -164,13 +165,7 @@ fn start_module_1(instance: &mut Instance) {
 // 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)),
-            Value::F32((0.00000000012345f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((1.1234568f32)), Value::F32((0.00000000012345f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.1234568f32)))));
     result.map(|_| ())
 }
@@ -178,13 +173,7 @@ fn c1_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.00000000012345f64)),
-        ],
-    );
+    let result = instance.call("f64.add", &[Value::F64((1.123456789f64)), Value::F64((0.00000000012345f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.12345678912345f64)))));
     result.map(|_| ())
 }
@@ -192,10 +181,7 @@ fn c2_l51_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.000000059604645f32))],
-    );
+    let result = instance.call("f32.add", &[Value::F32((1.0f32)), Value::F32((0.000000059604645f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -203,10 +189,7 @@ fn c3_l55_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.00000005960465f32))],
-    );
+    let result = instance.call("f32.add", &[Value::F32((1.0f32)), Value::F32((0.00000005960465f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0000001f32)))));
     result.map(|_| ())
 }
@@ -214,13 +197,7 @@ fn c4_l56_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.00000000000000011102230246251565f64)),
-        ],
-    );
+    let result = instance.call("f64.add", &[Value::F64((1.0f64)), Value::F64((0.00000000000000011102230246251565f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -228,13 +205,7 @@ fn c5_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.00000000000000011102230246251568f64)),
-        ],
-    );
+    let result = instance.call("f64.add", &[Value::F64((1.0f64)), Value::F64((0.00000000000000011102230246251568f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64)))));
     result.map(|_| ())
 }
@@ -242,19 +213,8 @@ fn c6_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754942f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754942f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -269,10 +229,7 @@ fn c8_l62_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1024.25f32))],
-    );
+    let result = instance.call("f32.add", &[Value::F32((2147483600.0f32)), Value::F32((1024.25f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2147484700.0f32)))));
     result.map(|_| ())
 }
@@ -280,13 +237,7 @@ fn c9_l67_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1024.25f64)),
-        ],
-    );
+    let result = instance.call("f64.add", &[Value::F64((9223372036854776000.0f64)), Value::F64((1024.25f64))]);
     assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64)))));
     result.map(|_| ())
 }
@@ -302,13 +253,7 @@ fn c11_l72_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.00001f64)),
-        ],
-    );
+    let result = instance.call("f64.add", &[Value::F64((9007199254740992.0f64)), Value::F64((1.00001f64))]);
     assert_eq!(result, Ok(Some(Value::F64((9007199254740994.0f64)))));
     result.map(|_| ())
 }
@@ -316,13 +261,7 @@ fn c12_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.9999847412109375f64)),
-        ],
-    );
+    let result = instance.call("f64.add", &[Value::F64((9007199254740994.0f64)), Value::F64((0.9999847412109375f64))]);
     assert_eq!(result, Ok(Some(Value::F64((9007199254740994.0f64)))));
     result.map(|_| ())
 }
@@ -330,10 +269,7 @@ fn c13_l78_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("f32.add", &[Value::F32((8388608.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((8388608.0f32)))));
     result.map(|_| ())
 }
@@ -341,10 +277,7 @@ fn c14_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.5f32))],
-    );
+    let result = instance.call("f32.add", &[Value::F32((8388609.0f32)), Value::F32((0.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((8388610.0f32)))));
     result.map(|_| ())
 }
@@ -352,10 +285,7 @@ fn c15_l82_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("f64.add", &[Value::F64((4503599627370496.0f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64)))));
     result.map(|_| ())
 }
@@ -363,10 +293,7 @@ fn c16_l83_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.5f64))],
-    );
+    let result = instance.call("f64.add", &[Value::F64((4503599627370497.0f64)), Value::F64((0.5f64))]);
     assert_eq!(result, Ok(Some(Value::F64((4503599627370498.0f64)))));
     result.map(|_| ())
 }
@@ -374,30 +301,15 @@ fn c17_l84_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000002309799f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-6207600000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.add", &[Value::F32((-6207600000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000002309799f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-6207600000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-5270152500000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((209865800000000000000.0f32)), Value::F32((-5270152500000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((209860530000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -405,30 +317,15 @@ fn c19_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000046220067f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000000000001963492f32))))
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.0000000000000000000000001963492f32)), Value::F32((0.000000000000000000000000000000000000046220067f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000001963492f32)))));
     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)),
-            Value::F32((-64449550000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((640905000000.0f32)), Value::F32((-64449550000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-64448910000000000.0f32)))));
     result.map(|_| ())
 }
@@ -436,17 +333,8 @@ fn c21_l90_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((120372790000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((120372790000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.0000601966f32)), Value::F32((120372790000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((120372790000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -454,44 +342,22 @@ fn c22_l91_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64)))));
     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)),
-            Value::F64(
-                (0.00000000000000000000000000000000000000000000000000000004670208988478548f64),
-            ),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-96503407870148960000000.0f64))))
-    );
+    let result = instance.call("f64.add", &[Value::F64((-96503407870148960000000.0f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000004670208988478548f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-96503407870148960000000.0f64)))));
     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)),
-            Value::F64((-0.00026124280570653086f64)),
-        ],
-    );
+    let result = instance.call("f64.add", &[Value::F64((0.0000000000000000000000000000000000000000000028559147675434106f64)), Value::F64((-0.00026124280570653086f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.00026124280570653086f64)))));
     result.map(|_| ())
 }
@@ -515,13 +381,7 @@ fn c27_l96_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1570182.5f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((5238404000000000000000.0f32)), Value::F32((-1570182.5f32))]);
     assert_eq!(result, Ok(Some(Value::F32((5238404000000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -529,13 +389,7 @@ fn c28_l99_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.0000000000000000000000057092353f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.00000000000004258938f32)), Value::F32((-0.0000000000000000000000057092353f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000000004258938f32)))));
     result.map(|_| ())
 }
@@ -543,32 +397,15 @@ fn c29_l100_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((83711560000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (83711560000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((-0.00000000000027251026f32)), Value::F32((83711560000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((83711560000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000015165626f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((-0.0000000000000884536f32)), Value::F32((-0.000000000000000000000000000000015165626f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000884536f32)))));
     result.map(|_| ())
 }
@@ -576,13 +413,7 @@ fn c31_l102_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000007582135f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.0010521035f32)), Value::F32((-0.000000000000000000000000000000007582135f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0010521035f32)))));
     result.map(|_| ())
 }
@@ -591,31 +422,15 @@ fn c32_l103_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002760218100603169f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (1511135228188924600000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((1511135228188924600000000000000000000000000000000000000.0f64)))));
     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)),
-            Value::F64((-0.0000000000000000008592185488839212f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (62386719760360280000000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.add", &[Value::F64((62386719760360280000000000000000000000000000000.0f64)), Value::F64((-0.0000000000000000008592185488839212f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((62386719760360280000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -630,19 +445,8 @@ fn c35_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-1112220412047137200000000000000000000000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-216332767126871650000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.add", &[Value::F64((-215220546714824520000000000000000000000000000.0f64)), Value::F64((-1112220412047137200000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-216332767126871650000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -657,13 +461,7 @@ fn c37_l108_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00000000000020219949f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000006456021f32)), Value::F32((0.00000000000020219949f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000000020219949f32)))));
     result.map(|_| ())
 }
@@ -671,13 +469,7 @@ fn c38_l111_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000011196016f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((-0.000026823169f32)), Value::F32((0.000000011196016f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.000026811973f32)))));
     result.map(|_| ())
 }
@@ -685,13 +477,7 @@ fn c39_l112_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000000000000000027356305f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((-128526170000.0f32)), Value::F32((0.0000000000000000000000000000000027356305f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-128526170000.0f32)))));
     result.map(|_| ())
 }
@@ -699,13 +485,7 @@ fn c40_l113_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-1573528700.0f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000004158973f32)), Value::F32((-1573528700.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-1573528700.0f32)))));
     result.map(|_| ())
 }
@@ -713,17 +493,8 @@ fn c41_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((78647514000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((78647514000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.add", &[Value::F32((-0.0000000000000000000000000000000000009338769f32)), Value::F32((78647514000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((78647514000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -843,107 +614,47 @@ fn c56_l133_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010865942283516648f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64)))));
     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)),
-            Value::F32((305590870000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (305688080000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((97215650000000000000000000000000000.0f32)), Value::F32((305590870000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((305688080000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-230236850000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (270465400000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((270465630000000000000000000000000000000.0f32)), Value::F32((-230236850000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((270465400000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-236494050000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-236136840000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((357209300000000000000000000000000000.0f32)), Value::F32((-236494050000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-236136840000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-328991400000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-330475620000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((-1484234100000000000000000000000000000.0f32)), Value::F32((-328991400000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-330475620000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-81560930000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-301446520000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((-219885600000000000000000000000000000000.0f32)), Value::F32((-81560930000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-301446520000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -990,95 +701,40 @@ fn c67_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000000873f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000008314328f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000008313455f32)), Value::F32((0.000000000000000000000000000000000000000000873f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000008314328f32)))));
     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)),
-            Value::F32((-0.000000000000000000000000000000000000000000003f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000049f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000052f32)), Value::F32((-0.000000000000000000000000000000000000000000003f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000049f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000005186284f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000005186273f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000000000000011f32)), Value::F32((0.000000000000000000000000000000000000005186284f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005186273f32)))));
     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)),
-            Value::F32((0.00000000000000000000000000000000000023675283f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.0000000000000000000000000000000000002367528f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000000000000028f32)), Value::F32((0.00000000000000000000000000000000000023675283f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000002367528f32)))));
     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)),
-            Value::F32((-0.00000000000000000000000000000000000000003327f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000000032635f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000635f32)), Value::F32((-0.00000000000000000000000000000000000000003327f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000032635f32)))));
     result.map(|_| ())
 }
 
@@ -1125,19 +781,8 @@ fn c77_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((20282410000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((340282330000000000000000000000000000000.0f32)), Value::F32((20282410000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -1168,32 +813,15 @@ fn c81_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((10141204000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((10141204000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((10141205000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((10141205000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -1217,13 +845,7 @@ fn c85_l173_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000007275958f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((65536.0f32)), Value::F32((0.000000000007275958f32))]);
     assert_eq!(result, Ok(Some(Value::F32((65536.0f32)))));
     result.map(|_| ())
 }
@@ -1231,13 +853,7 @@ fn c86_l177_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.000000000007275957614183426f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((65536.0f64)), Value::F64((0.000000000007275957614183426f64))]);
     assert_eq!(result, Ok(Some(Value::F64((65535.99999999999f64)))));
     result.map(|_| ())
 }
@@ -1245,10 +861,7 @@ fn c87_l178_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.000000029802322f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((1.0f32)), Value::F32((0.000000029802322f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -1256,10 +869,7 @@ fn c88_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.000000029802326f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((1.0f32)), Value::F32((0.000000029802326f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.99999994f32)))));
     result.map(|_| ())
 }
@@ -1267,13 +877,7 @@ fn c89_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.00000000000000005551115123125783f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((1.0f64)), Value::F64((0.00000000000000005551115123125783f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1281,13 +885,7 @@ fn c90_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.00000000000000005551115123125784f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((1.0f64)), Value::F64((0.00000000000000005551115123125784f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.9999999999999999f64)))));
     result.map(|_| ())
 }
@@ -1295,51 +893,23 @@ fn c91_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-722129800000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (722129800000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((0.00000000000000000000000000000002379208f32)), Value::F32((-722129800000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((722129800000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-11118414000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-842284000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-842284000000000000000000000000000000.0f32)), Value::F32((-11118414000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-842284000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.00000000000000000000000033792615f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((1.4549444f32)), Value::F32((-0.00000000000000000000000033792615f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.4549444f32)))));
     result.map(|_| ())
 }
@@ -1347,30 +917,15 @@ fn c94_l190_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000018589502f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.000000000000000000000018589502f32))))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((0.0000000000000000000000000000000000094808914f32)), Value::F32((0.000000000000000000000018589502f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000018589502f32)))));
     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)),
-            Value::F32((-0.0000000000000000000000000000000093959864f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((0.000006181167f32)), Value::F32((-0.0000000000000000000000000000000093959864f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.000006181167f32)))));
     result.map(|_| ())
 }
@@ -1403,12 +958,7 @@ fn c99_l195_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-23204941114021897000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (23204941114021897000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((23204941114021897000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -1416,59 +966,30 @@ fn c100_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010592252695645683f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.00000000000000000000000000000000000000000014953904039036317f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000014953904039036317f64)))));
     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)),
-            Value::F32((-8984148000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((8535546400000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-448601660000000000000000000000000.0f32)), Value::F32((-8984148000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((8535546400000000000000000000000000.0f32)))));
     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)),
-            Value::F32((91.579384f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-899427400000000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-899427400000000000000000000000000.0f32)), Value::F32((91.579384f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-899427400000000000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000063140405f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-0.00000000000000000000000011975f32)), Value::F32((0.000000063140405f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.000000063140405f32)))));
     result.map(|_| ())
 }
@@ -1476,13 +997,7 @@ fn c104_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.00031558736f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-0.000000000000000000000011800487f32)), Value::F32((-0.00031558736f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00031558736f32)))));
     result.map(|_| ())
 }
@@ -1490,17 +1005,8 @@ fn c105_l203_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000030824513f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-736483800000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-736483800000000000000000000000.0f32)), Value::F32((0.0000000000000000030824513f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-736483800000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -1524,12 +1030,7 @@ fn c108_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001572015082308034f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64)))));
     result.map(|_| ())
 }
 
@@ -1544,49 +1045,23 @@ fn c110_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((4447012580193329000000000000000000000000000000000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-4447012580193329000000000000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.sub", &[Value::F64((-7538298763725556000000000000000000.0f64)), Value::F64((4447012580193329000000000000000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-4447012580193329000000000000000000000000000000000000.0f64)))));
     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)),
-            Value::F32((0.000046391753f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((75846976000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((75846976000000000000000000000.0f32)), Value::F32((0.000046391753f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((75846976000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.000000000030334842f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-567139.9f32)), Value::F32((-0.000000000030334842f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-567139.9f32)))));
     result.map(|_| ())
 }
@@ -1594,13 +1069,7 @@ fn c113_l213_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000017877793f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-0.000000000017412261f32)), Value::F32((-0.000000000000000017877793f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.000000000017412244f32)))));
     result.map(|_| ())
 }
@@ -1608,13 +1077,7 @@ fn c114_l214_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00014473806f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-0.000065645545f32)), Value::F32((0.00014473806f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00021038362f32)))));
     result.map(|_| ())
 }
@@ -1622,13 +1085,7 @@ fn c115_l215_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000000085380075f32)),
-        ],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((-0.00000000016016115f32)), Value::F32((-0.000000000000000000000000000000085380075f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00000000016016115f32)))));
     result.map(|_| ())
 }
@@ -1653,12 +1110,7 @@ fn c118_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((3383199683245004400000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-3383199683245004400000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-3383199683245004400000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -1681,19 +1133,8 @@ fn c121_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.000000000000000000000000000000000025021499241540866f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.000000000000000000000005816988065768018f64)
-        )))
-    );
+    let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000005816988065793039f64)), Value::F64((0.000000000000000000000000000000000025021499241540866f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000005816988065768018f64)))));
     result.map(|_| ())
 }
 
@@ -1709,42 +1150,22 @@ fn c123_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64)))));
     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)),
-            Value::F64((-0.0000000000000000000027947429925618632f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.000000000002204429151949638f64))))
-    );
+    let result = instance.call("f64.sub", &[Value::F64((-0.0000000000022044291547443813f64)), Value::F64((-0.0000000000000000000027947429925618632f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.000000000002204429151949638f64)))));
     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)),
-            Value::F64((0.17053881989395447f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((0.00000004016393569117761f64)), Value::F64((0.17053881989395447f64))]);
     assert_eq!(result, Ok(Some(Value::F64((-0.17053877973001877f64)))));
     result.map(|_| ())
 }
@@ -1769,10 +1190,7 @@ fn c128_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042192279274320304f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((38832071540376680000000000000000000.0f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((38832071540376680000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -1788,20 +1206,14 @@ fn c130_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014584885434950294f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.00000000000000000949378346261834f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000949378346261834f64)))));
     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)), Value::F32((3.1415927f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((23.140692f32)), Value::F32((3.1415927f32))]);
     assert_eq!(result, Ok(Some(Value::F32((19.9991f32)))));
     result.map(|_| ())
 }
@@ -1809,13 +1221,7 @@ fn c132_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((3.141592653589793f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((23.14069263277927f64)), Value::F64((3.141592653589793f64))]);
     assert_eq!(result, Ok(Some(Value::F64((19.999099979189477f64)))));
     result.map(|_| ())
 }
@@ -1823,10 +1229,7 @@ fn c133_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((2999998.0f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((2999999.0f32)), Value::F32((2999998.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -1834,10 +1237,7 @@ fn c134_l243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1999995.0f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((1999999.0f32)), Value::F32((1999995.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((4.0f32)))));
     result.map(|_| ())
 }
@@ -1845,10 +1245,7 @@ fn c135_l244_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1999993.0f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((1999999.0f32)), Value::F32((1999993.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((6.0f32)))));
     result.map(|_| ())
 }
@@ -1856,10 +1253,7 @@ fn c136_l245_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((400001.0f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((400002.0f32)), Value::F32((400001.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -1867,10 +1261,7 @@ fn c137_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((400000.0f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((400002.0f32)), Value::F32((400000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2.0f32)))));
     result.map(|_| ())
 }
@@ -1878,13 +1269,7 @@ fn c138_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((2999999999999998.0f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((2999999999999999.0f64)), Value::F64((2999999999999998.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1892,13 +1277,7 @@ fn c139_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1999999999999995.0f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((1999999999999999.0f64)), Value::F64((1999999999999995.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((4.0f64)))));
     result.map(|_| ())
 }
@@ -1906,13 +1285,7 @@ fn c140_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1999999999999993.0f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((1999999999999999.0f64)), Value::F64((1999999999999993.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6.0f64)))));
     result.map(|_| ())
 }
@@ -1920,13 +1293,7 @@ fn c141_l250_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((400000000000001.0f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((400000000000002.0f64)), Value::F64((400000000000001.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -1934,13 +1301,7 @@ fn c142_l251_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((400000000000000.0f64)),
-        ],
-    );
+    let result = instance.call("f64.sub", &[Value::F64((400000000000002.0f64)), Value::F64((400000000000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((2.0f64)))));
     result.map(|_| ())
 }
@@ -1948,19 +1309,8 @@ fn c143_l252_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754942f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754942f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -1975,10 +1325,7 @@ fn c145_l256_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.99999994f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000017881393f32)))));
     result.map(|_| ())
 }
@@ -1986,10 +1333,7 @@ fn c146_l259_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((1.0000001f32)), Value::F32((1.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32)))));
     result.map(|_| ())
 }
@@ -1997,10 +1341,7 @@ fn c147_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.99999994f32))],
-    );
+    let result = instance.call("f32.sub", &[Value::F32((1.0f32)), Value::F32((0.99999994f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.000000059604645f32)))));
     result.map(|_| ())
 }
@@ -2008,83 +1349,40 @@ fn c148_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.9999999999999999f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.00000000000000033306690738754696f64))))
-    );
+    let result = instance.call("f64.sub", &[Value::F64((1.0000000000000002f64)), Value::F64((0.9999999999999999f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000033306690738754696f64)))));
     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)), Value::F64((1.0f64))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.0000000000000002220446049250313f64))))
-    );
+    let result = instance.call("f64.sub", &[Value::F64((1.0000000000000002f64)), Value::F64((1.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))));
     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)), Value::F64((0.9999999999999999f64))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.00000000000000011102230246251565f64))))
-    );
+    let result = instance.call("f64.sub", &[Value::F64((1.0f64)), Value::F64((0.9999999999999999f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000011102230246251565f64)))));
     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)),
-            Value::F32((10141204000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282350000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((10141204000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((10141205000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282330000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((10141205000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -2107,30 +1405,15 @@ fn c155_l271_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((999999940000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((1000000000000000.0f32)), Value::F32((1000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((999999940000000000000000000000.0f32)))));
     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)),
-            Value::F32((100000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((100000000000000000000.0f32)), Value::F32((100000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -2138,13 +1421,7 @@ fn c157_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((10000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((10000000000000000000000000.0f32)), Value::F32((10000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -2152,68 +1429,31 @@ fn c158_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1000000000000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((1000000000000000000000000000000.0f64))))
-    );
+    let result = instance.call("f64.mul", &[Value::F64((1000000000000000.0f64)), Value::F64((1000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((1000000000000000000000000000000.0f64)))));
     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)),
-            Value::F64((100000000000000000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (10000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.mul", &[Value::F64((100000000000000000000.0f64)), Value::F64((100000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((10000000000000000000000000000000000000000.0f64)))));
     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)),
-            Value::F64((10000000000000000000000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (100000000000000030000000000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.mul", &[Value::F64((10000000000000000000000000.0f64)), Value::F64((10000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((100000000000000030000000000000000000000000000000000.0f64)))));
     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)),
-            Value::F32((19954563000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((1848874900.0f32)), Value::F32((19954563000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((36893493000000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2221,13 +1461,7 @@ fn c162_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((19954562207.0f64)),
-        ],
-    );
+    let result = instance.call("f64.mul", &[Value::F64((1848874847.0f64)), Value::F64((19954562207.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((36893488147419110000.0f64)))));
     result.map(|_| ())
 }
@@ -2251,13 +1485,7 @@ fn c165_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000021176054f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-2493839400000000000.0f32)), Value::F32((0.000000000021176054f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-52809680.0f32)))));
     result.map(|_| ())
 }
@@ -2265,13 +1493,7 @@ fn c166_l293_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.00000000000000000000000000000034758242f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-6777248400000000000000000000000.0f32)), Value::F32((-0.00000000000000000000000000000034758242f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2.3556523f32)))));
     result.map(|_| ())
 }
@@ -2279,13 +1501,7 @@ fn c167_l294_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000000000011948991f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-8384397600000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000011948991f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.10018509f32)))));
     result.map(|_| ())
 }
@@ -2293,13 +1509,7 @@ fn c168_l295_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-0.000000000000000000000046889766f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-656765400000000000000000.0f32)), Value::F32((-0.000000000000000000000046889766f32))]);
     assert_eq!(result, Ok(Some(Value::F32((30.795576f32)))));
     result.map(|_| ())
 }
@@ -2307,13 +1517,7 @@ fn c169_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((45.567223f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((13328204000000000.0f32)), Value::F32((45.567223f32))]);
     assert_eq!(result, Ok(Some(Value::F32((607329200000000000.0f32)))));
     result.map(|_| ())
 }
@@ -2354,23 +1558,14 @@ fn c174_l301_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007842892881810105f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.00000000000000000019908317594263248f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000019908317594263248f64)))));
     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)),
-            Value::F32((-5031353000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-0.0000000000000000000000000020153333f32)), Value::F32((-5031353000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((10.139854f32)))));
     result.map(|_| ())
 }
@@ -2378,30 +1573,15 @@ fn c176_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((749601.8f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((9209852000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((12286325000000000000000.0f32)), Value::F32((749601.8f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((9209852000000000000000000000.0f32)))));
     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)),
-            Value::F32((-35524714000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-0.0000000002763514f32)), Value::F32((-35524714000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((9817304000000.0f32)))));
     result.map(|_| ())
 }
@@ -2409,34 +1589,16 @@ fn c178_l307_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-40298.785f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-8822662000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((218931220000000000000.0f32)), Value::F32((-40298.785f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-8822662000000000000000000.0f32)))));
     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)),
-            Value::F32((-122103350000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-206598410000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((1691996300.0f32)), Value::F32((-122103350000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-206598410000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -2483,13 +1645,7 @@ fn c185_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-54038020000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-110087030000000.0f32)), Value::F32((-54038020000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -2497,49 +1653,23 @@ fn c186_l317_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000000000000029748954f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.0000000000000000000000000000005761287f32)
-        )))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-0.19366351f32)), Value::F32((0.0000000000000000000000000000029748954f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000000005761287f32)))));
     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)),
-            Value::F32((77991523000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-267516490000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-0.0000034300713f32)), Value::F32((77991523000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-267516490000000000000000000.0f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000020933774f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-99003850000000000.0f32)), Value::F32((0.000000000000000000000000000020933774f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.0000000000020725242f32)))));
     result.map(|_| ())
 }
@@ -2547,19 +1677,8 @@ fn c189_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000000000000000000018480999f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.00000000000000000000000000000024010342f32)
-        )))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-129919.07f32)), Value::F32((0.0000000000000000000000000000000000018480999f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000024010342f32)))));
     result.map(|_| ())
 }
 
@@ -2567,10 +1686,7 @@ fn c190_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-37374020681740010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.00000000000000000024762427246273877f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000024762427246273877f64)))));
     result.map(|_| ())
 }
 
@@ -2601,19 +1717,8 @@ fn c194_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1225791423971563000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (4176317714919266400000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.mul", &[Value::F64((3407037798802672000000000.0f64)), Value::F64((1225791423971563000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((4176317714919266400000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -2701,46 +1806,23 @@ fn c205_l340_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007021344893525714f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.000000003270292605938992f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.000000003270292605938992f64)))));
     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)),
-            Value::F64((0.000000000000000000000000000000000000000000001945309177849331f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.00000000000000000000000000000000000000000000002422243795617958f64)
-        )))
-    );
+    let result = instance.call("f64.mul", &[Value::F64((0.012451716278313712f64)), Value::F64((0.000000000000000000000000000000000000000000001945309177849331f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000002422243795617958f64)))));
     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)),
-            Value::F64((0.0000000000009039887741742674f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000034633902471580017f64))))
-    );
+    let result = instance.call("f64.mul", &[Value::F64((-3.8312314777598586f64)), Value::F64((0.0000000000009039887741742674f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000034633902471580017f64)))));
     result.map(|_| ())
 }
 
@@ -2763,13 +1845,7 @@ fn c210_l347_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00000000000000000000002646978f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((0.00000000000000000000002646978f32)), Value::F32((0.00000000000000000000002646978f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -2777,19 +1853,8 @@ fn c211_l350_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000026469783f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((0.000000000000000000000026469783f32)), Value::F32((0.000000000000000000000026469783f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -2812,32 +1877,15 @@ fn c214_l353_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((18446743000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282330000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((18446743000000000000.0f32)), Value::F32((18446743000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32)))));
     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)),
-            Value::F32((18446744000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((18446744000000000000.0f32)), Value::F32((18446744000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -2861,10 +1909,7 @@ fn c218_l359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0000001f32))],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((1.0000001f32)), Value::F32((1.0000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0000002f32)))));
     result.map(|_| ())
 }
@@ -2872,10 +1917,7 @@ fn c219_l362_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.99999994f32))],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((0.99999994f32)), Value::F32((0.99999994f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.9999999f32)))));
     result.map(|_| ())
 }
@@ -2883,13 +1925,7 @@ fn c220_l363_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0000000000000002f64)),
-        ],
-    );
+    let result = instance.call("f64.mul", &[Value::F64((1.0000000000000002f64)), Value::F64((1.0000000000000002f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0000000000000004f64)))));
     result.map(|_| ())
 }
@@ -2897,13 +1933,7 @@ fn c221_l364_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.9999999999999999f64)),
-        ],
-    );
+    let result = instance.call("f64.mul", &[Value::F64((0.9999999999999999f64)), Value::F64((0.9999999999999999f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64)))));
     result.map(|_| ())
 }
@@ -2911,10 +1941,7 @@ fn c222_l365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.99999994f32))],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -2922,10 +1949,7 @@ fn c223_l368_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.9999999f32))],
-    );
+    let result = instance.call("f32.mul", &[Value::F32((1.0000002f32)), Value::F32((0.9999999f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0000001f32)))));
     result.map(|_| ())
 }
@@ -2933,13 +1957,7 @@ fn c224_l369_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.9999999999999999f64)),
-        ],
-    );
+    let result = instance.call("f64.mul", &[Value::F64((1.0000000000000002f64)), Value::F64((0.9999999999999999f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -2947,13 +1965,7 @@ fn c225_l370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.9999999999999998f64)),
-        ],
-    );
+    let result = instance.call("f64.mul", &[Value::F64((1.0000000000000004f64)), Value::F64((0.9999999999999998f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64)))));
     result.map(|_| ())
 }
@@ -2961,19 +1973,8 @@ fn c226_l371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.00000011920929f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.00000011920929f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -2988,29 +1989,15 @@ fn c228_l376_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000000298465f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-0.000000000000000000000000000000000000004775883f32)
-        )))
-    );
+    let result = instance.call("f32.mul", &[Value::F32((-16.001465f32)), Value::F32((0.000000000000000000000000000000000000000298465f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000004775883f32)))));
     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)), Value::F32((100.0f32))],
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.1234568f32)), Value::F32((100.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.011234568f32)))));
     result.map(|_| ())
 }
@@ -3018,10 +2005,7 @@ fn c230_l382_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((12582905.0f32))],
-    );
+    let result = instance.call("f32.div", &[Value::F32((8391667.0f32)), Value::F32((12582905.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.6669102f32)))));
     result.map(|_| ())
 }
@@ -3029,13 +2013,7 @@ fn c231_l383_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000007275958f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((65536.0f32)), Value::F32((0.000000000007275958f32))]);
     assert_eq!(result, Ok(Some(Value::F32((9007199000000000.0f32)))));
     result.map(|_| ())
 }
@@ -3043,19 +2021,8 @@ fn c232_l384_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000005472795f32)
-        )))
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.8622957f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005472795f32)))));
     result.map(|_| ())
 }
 
@@ -3070,10 +2037,7 @@ fn c234_l386_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((100.0f64))],
-    );
+    let result = instance.call("f64.div", &[Value::F64((1.123456789f64)), Value::F64((100.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.01123456789f64)))));
     result.map(|_| ())
 }
@@ -3081,10 +2045,7 @@ fn c235_l387_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((12582905.0f64))],
-    );
+    let result = instance.call("f64.div", &[Value::F64((8391667.0f64)), Value::F64((12582905.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.6669101451532854f64)))));
     result.map(|_| ())
 }
@@ -3092,13 +2053,7 @@ fn c236_l388_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.000000000007275957614183426f64)),
-        ],
-    );
+    let result = instance.call("f64.div", &[Value::F64((65536.0f64)), Value::F64((0.000000000007275957614183426f64))]);
     assert_eq!(result, Ok(Some(Value::F64((9007199254740992.0f64)))));
     result.map(|_| ())
 }
@@ -3122,10 +2077,7 @@ fn c239_l391_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((3145727.0f32))],
-    );
+    let result = instance.call("f32.div", &[Value::F32((4195835.0f32)), Value::F32((3145727.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.3338205f32)))));
     result.map(|_| ())
 }
@@ -3133,10 +2085,7 @@ fn c240_l395_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((3145727.0f64))],
-    );
+    let result = instance.call("f64.div", &[Value::F64((4195835.0f64)), Value::F64((3145727.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.333820449136241f64)))));
     result.map(|_| ())
 }
@@ -3144,13 +2093,7 @@ fn c241_l396_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((336324380000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.000000000000005029633f32)), Value::F32((336324380000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -3158,13 +2101,7 @@ fn c242_l399_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((354097530000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000008921987f32)), Value::F32((354097530000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -3172,30 +2109,15 @@ fn c243_l400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000000015866623f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-65651950000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.div", &[Value::F32((-104167.47f32)), Value::F32((0.0000000000000000000000015866623f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-65651950000000000000000000000.0f32)))));
     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)),
-            Value::F32((-0.00000000000000000000000000000000000036230088f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((-0.000000000000000000000024938657f32)), Value::F32((-0.00000000000000000000000000000000000036230088f32))]);
     assert_eq!(result, Ok(Some(Value::F32((68834107000000.0f32)))));
     result.map(|_| ())
 }
@@ -3203,38 +2125,16 @@ fn c245_l402_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.0000000000000000000000011954948f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (-3464845000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.div", &[Value::F32((-4142204200000.0f32)), Value::F32((0.0000000000000000000000011954948f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-3464845000000000000000000000000000000.0f32)))));
     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)),
-            Value::F64((25290742357348314000000000000000000000000000000000000000000000000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.000000000000000000000007666883046955921f64)
-        )))
-    );
+    let result = instance.call("f64.div", &[Value::F64((193901163824483840000000000000000000000000000.0f64)), Value::F64((25290742357348314000000000000000000000000000000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000007666883046955921f64)))));
     result.map(|_| ())
 }
 
@@ -3266,23 +2166,14 @@ fn c250_l407_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((31282495822334530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-145968816036246260000000000.0f64))))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((-145968816036246260000000000.0f64)))));
     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)),
-            Value::F32((-0.000000000000000000000000012965966f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((-1039406400000000000000.0f32)), Value::F32((-0.000000000000000000000000012965966f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3290,64 +2181,31 @@ fn c252_l411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((31241038000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000000000000008588563f32))))
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.000000000000026831563f32)), Value::F32((31241038000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000008588563f32)))));
     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)),
-            Value::F32((-692783700000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.0000000000000000000000000018381274f32))))
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.2734247f32)), Value::F32((-692783700000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000018381274f32)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000003762676f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((183350460000000000000000.0f32))))
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.00000000000000068988827f32)), Value::F32((0.000000000000000000000000000000000000003762676f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((183350460000000000000000.0f32)))));
     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)),
-            Value::F32((205067030000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((1819916200000000000000000000.0f32)), Value::F32((205067030000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((8.874739f32)))));
     result.map(|_| ())
 }
@@ -3387,34 +2245,15 @@ fn c260_l419_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-            ),
-            Value::F64((-70026160475217470.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (2476057121342590000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    let result = instance.call("f64.div", &[Value::F64((-173388773324941200000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-70026160475217470.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((2476057121342590000000000000000000000000000000000000000.0f64)))));
     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)),
-            Value::F32((0.0000000000000000000000000000000000028760885f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((93506190.0f32)), Value::F32((0.0000000000000000000000000000000000028760885f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3422,13 +2261,7 @@ fn c262_l423_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((246697220.0f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((-200575400000000000000000.0f32)), Value::F32((246697220.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-813042800000000.0f32)))));
     result.map(|_| ())
 }
@@ -3436,51 +2269,24 @@ fn c263_l424_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-107037850000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((-0.00000000000000000359417f32))))
-    );
+    let result = instance.call("f32.div", &[Value::F32((384712200000.0f32)), Value::F32((-107037850000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000359417f32)))));
     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)),
-            Value::F32((-901.4192f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((4611245300000000000000000000000.0f32))))
-    );
+    let result = instance.call("f32.div", &[Value::F32((-4156665000000000000000000000000000.0f32)), Value::F32((-901.4192f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((4611245300000000000000000000000.0f32)))));
     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)),
-            Value::F32((-14000.255f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((478733200000000000000000.0f32))))
-    );
+    let result = instance.call("f32.div", &[Value::F32((-6702387000000000000000000000.0f32)), Value::F32((-14000.255f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((478733200000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -3519,17 +2325,8 @@ fn c270_l431_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-47097881971884274000000000000000000000000000000000000000000000000.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000857778757955442f64))))
-    );
+    let result = instance.call("f64.div", &[Value::F64((4039956270017490000000000000000000000000000000000000000.0f64)), Value::F64((-47097881971884274000000000000000000000000000000000000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000857778757955442f64)))));
     result.map(|_| ())
 }
 
@@ -3545,12 +2342,7 @@ fn c272_l435_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((-2655679232658824300000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (114570204320220420000000000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((114570204320220420000000000000000000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -3566,12 +2358,7 @@ fn c274_l437_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)), Value::F64((517194875837335500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.0000000000000000000000000000000000000000000000000000000000000005592879146144478f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000005592879146144478f64)))));
     result.map(|_| ())
 }
 
@@ -3634,13 +2421,7 @@ fn c282_l447_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((6211079500000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((1038860800000000000000000000.0f32)), Value::F32((6211079500000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((167259300000000.0f32)))));
     result.map(|_| ())
 }
@@ -3648,13 +2429,7 @@ fn c283_l450_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-112355730000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((1869033000000000000000000000.0f32)), Value::F32((-112355730000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((-0.00001663496f32)))));
     result.map(|_| ())
 }
@@ -3662,27 +2437,15 @@ fn c284_l451_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.9064788f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((3630252700000000000000000.0f32))))
-    );
+    let result = instance.call("f32.div", &[Value::F32((3290747200000000000000000.0f32)), Value::F32((0.9064788f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((3630252700000000000000000.0f32)))));
     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)), Value::F32((-17034289000.0f32))],
-    );
+    let result = instance.call("f32.div", &[Value::F32((-908946.56f32)), Value::F32((-17034289000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.000053359818f32)))));
     result.map(|_| ())
 }
@@ -3690,19 +2453,8 @@ fn c286_l453_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((-89840810000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.0000000000000000000000000000026816852f32)
-        )))
-    );
+    let result = instance.call("f32.div", &[Value::F32((-0.00000000000024092477f32)), Value::F32((-89840810000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000026816852f32)))));
     result.map(|_| ())
 }
 
@@ -3749,47 +2501,23 @@ fn c292_l459_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.8150892711657447f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((0.000000000000000005764217160391678f64))))
-    );
+    let result = instance.call("f64.div", &[Value::F64((0.00000000000000001046256872449641f64)), Value::F64((1.8150892711657447f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000005764217160391678f64)))));
     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)),
-            Value::F64((-0.0000000000002859803943943555f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((-0.0000000000000000007706216418530616f64))))
-    );
+    let result = instance.call("f64.div", &[Value::F64((0.00000000000000000000000000000022038268106596436f64)), Value::F64((-0.0000000000002859803943943555f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000007706216418530616f64)))));
     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)),
-            Value::F64((0.00000000000000000000000000000000021055358831337124f64)),
-        ],
-    );
+    let result = instance.call("f64.div", &[Value::F64((0.0000000000007596539988437179f64)), Value::F64((0.00000000000000000000000000000000021055358831337124f64))]);
     assert_eq!(result, Ok(Some(Value::F64((3607889112357986600000.0f64)))));
     result.map(|_| ())
 }
@@ -3797,13 +2525,7 @@ fn c295_l464_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((159713233802866500000000000000.0f64)),
-        ],
-    );
+    let result = instance.call("f64.div", &[Value::F64((1120696114500866900000000000.0f64)), Value::F64((159713233802866500000000000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.007016927074960728f64)))));
     result.map(|_| ())
 }
@@ -3811,32 +2533,15 @@ fn c296_l465_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-6391950865520085.0f64)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (-0.00000000000000000009922076429769178f64)
-        )))
-    );
+    let result = instance.call("f64.div", &[Value::F64((0.0006342142502301953f64)), Value::F64((-6391950865520085.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000009922076429769178f64)))));
     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)),
-            Value::F32((0.000000000000000000000000000000000000011754942f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754942f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0000001f32)))));
     result.map(|_| ())
 }
@@ -3844,13 +2549,7 @@ fn c298_l469_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000011754944f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000000000000000011754942f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.9999999f32)))));
     result.map(|_| ())
 }
@@ -3874,13 +2573,7 @@ fn c301_l472_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.00000023841856f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.0f32)))));
     result.map(|_| ())
 }
@@ -3888,19 +2581,8 @@ fn c302_l475_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((340282350000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000000000001f32)
-        )))
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.00000023841858f32)), Value::F32((340282350000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32)))));
     result.map(|_| ())
 }
 
@@ -3923,13 +2605,7 @@ fn c305_l478_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000002938736f32)),
-        ],
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000002938736f32))]);
     assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY))));
     result.map(|_| ())
 }
@@ -3937,19 +2613,8 @@ fn c306_l481_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((0.000000000000000000000000000000000000002938737f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (340282200000000000000000000000000000000.0f32)
-        )))
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000002938737f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((340282200000000000000000000000000000000.0f32)))));
     result.map(|_| ())
 }
 
@@ -3972,38 +2637,16 @@ fn c309_l484_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((85070600000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754942f32)
-        )))
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((85070600000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32)))));
     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)),
-            Value::F32((85070590000000000000000000000000000000.0f32)),
-        ],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32(
-            (0.000000000000000000000000000000000000011754944f32)
-        )))
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((85070590000000000000000000000000000000.0f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32)))));
     result.map(|_| ())
 }
 
@@ -4074,10 +2717,7 @@ fn c319_l505_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.99999994f32))],
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0000002f32)))));
     result.map(|_| ())
 }
@@ -4085,10 +2725,7 @@ fn c320_l508_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0000001f32))],
-    );
+    let result = instance.call("f32.div", &[Value::F32((0.99999994f32)), Value::F32((1.0000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.9999998f32)))));
     result.map(|_| ())
 }
@@ -4096,10 +2733,7 @@ fn c321_l509_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((0.99999994f32))],
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((0.99999994f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1.0000001f32)))));
     result.map(|_| ())
 }
@@ -4107,10 +2741,7 @@ fn c322_l510_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((1.0000001f32))],
-    );
+    let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((1.0000001f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.9999999f32)))));
     result.map(|_| ())
 }
@@ -4118,13 +2749,7 @@ fn c323_l511_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((0.9999999999999999f64)),
-        ],
-    );
+    let result = instance.call("f64.div", &[Value::F64((1.0000000000000002f64)), Value::F64((0.9999999999999999f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0000000000000004f64)))));
     result.map(|_| ())
 }
@@ -4132,13 +2757,7 @@ fn c324_l512_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0000000000000002f64)),
-        ],
-    );
+    let result = instance.call("f64.div", &[Value::F64((0.9999999999999999f64)), Value::F64((1.0000000000000002f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.9999999999999997f64)))));
     result.map(|_| ())
 }
@@ -4146,10 +2765,7 @@ fn c325_l513_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((0.9999999999999999f64))],
-    );
+    let result = instance.call("f64.div", &[Value::F64((1.0f64)), Value::F64((0.9999999999999999f64))]);
     assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64)))));
     result.map(|_| ())
 }
@@ -4157,10 +2773,7 @@ fn c326_l514_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((1.0000000000000002f64))],
-    );
+    let result = instance.call("f64.div", &[Value::F64((1.0f64)), Value::F64((1.0000000000000002f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64)))));
     result.map(|_| ())
 }
@@ -4200,18 +2813,8 @@ fn c331_l522_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.00000000000000000000000020775845543209175f64)
-        )))
-    );
+    let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000004316357580352844f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000020775845543209175f64)))));
     result.map(|_| ())
 }
 
@@ -4219,12 +2822,7 @@ fn c332_l525_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (822346216918183800000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((822346216918183800000000000000000000000000000000000.0f64)))));
     result.map(|_| ())
 }
 
@@ -4232,22 +2830,14 @@ fn c333_l526_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (4181542373916829400000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((4181542373916829400000000000000000000000000000000000000000000.0f64)))));
     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))],
-    );
+    let result = instance.call("f64.sqrt", &[Value::F64((0.000000000009593720960603523f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.0000030973732355987585f64)))));
     result.map(|_| ())
 }
@@ -4256,12 +2846,7 @@ fn c335_l528_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.00000000000000000000000000000000000000000000000000000002519613640762773f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000002519613640762773f64)))));
     result.map(|_| ())
 }
 
@@ -4284,10 +2869,7 @@ fn c338_l536_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.sqrt", &[Value::F32((2345875800000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((1531625200000000.0f32)))));
     result.map(|_| ())
 }
@@ -4303,10 +2885,7 @@ fn c340_l538_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000051371026f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.000000000022665177f32)))));
     result.map(|_| ())
 }
@@ -4339,22 +2918,14 @@ fn c344_l542_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (12153464517715332000000000000000000000000000000000000000000.0f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((12153464517715332000000000000000000000000000000000000000000.0f64)))));
     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))],
-    );
+    let result = instance.call("f64.sqrt", &[Value::F64((48800457180027890000000000000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((6985732401117859.0f64)))));
     result.map(|_| ())
 }
@@ -4378,10 +2949,7 @@ fn c348_l548_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000000000000000010471305f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000000000001023294f32)))));
     result.map(|_| ())
 }
@@ -4397,32 +2965,16 @@ fn c350_l550_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.0000000000000000009466126f32))))
-    );
+    let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000000000000000000089607535f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000009466126f32)))));
     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),
-        )],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F32((0.00000000000000000041081773f32))))
-    );
+    let result = instance.call("f32.sqrt", &[Value::F32((0.0000000000000000000000000000000000001687712f32))]);
+    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000041081773f32)))));
     result.map(|_| ())
 }
 
@@ -4454,12 +3006,7 @@ fn c355_l555_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.0000000000000000000000000000000000005312971794533864f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000005312971794533864f64)))));
     result.map(|_| ())
 }
 
@@ -4474,10 +3021,7 @@ fn c357_l557_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.sqrt", &[Value::F32((464023420000000000000000000000000000.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((681192700000000000.0f32)))));
     result.map(|_| ())
 }
@@ -4501,10 +3045,7 @@ fn c360_l562_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.sqrt", &[Value::F32((0.000000000000000000000000009549605f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.00000000000009772208f32)))));
     result.map(|_| ())
 }
@@ -4512,10 +3053,7 @@ fn c361_l563_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f32.sqrt", &[Value::F32((0.000000000000000000000000000068856485f32))]);
     assert_eq!(result, Ok(Some(Value::F32((0.000000000000008297981f32)))));
     result.map(|_| ())
 }
@@ -4532,12 +3070,7 @@ fn c363_l565_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.0000000000000000000000000000000000000000000000000000000005409489323718985f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000005409489323718985f64)))));
     result.map(|_| ())
 }
 
@@ -4552,10 +3085,7 @@ fn c365_l567_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
+    let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000035498432023945234f64))]);
     assert_eq!(result, Ok(Some(Value::F64((0.00000018841027579180822f64)))));
     result.map(|_| ())
 }
@@ -4570,25 +3100,19 @@ fn c367_l569_action_invoke(instance: &mut Instance) -> Result<(), String> {
 
 // Line 572
 fn c368_l572_assert_return_canonical_nan(instance: &mut Instance) {
-    println!(
-        "Executing function {}",
-        "c368_l572_assert_return_canonical_nan"
-    );
+    println!("Executing function {}", "c368_l572_assert_return_canonical_nan");
     let result = instance.call("f64.sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015535152663257847f64))]).unwrap().expect("Missing result in c368_l572_assert_return_canonical_nan");
     assert!(match result {
         Value::F32(fp) => fp.is_quiet_nan(),
         Value::F64(fp) => fp.is_quiet_nan(),
-        _ => unimplemented!(),
+        _ => 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))],
-    );
+    let result = instance.call("f64.sqrt", &[Value::F64((18763296348029700000000000000000.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((4331662076851067.0f64)))));
     result.map(|_| ())
 }
@@ -4605,12 +3129,7 @@ fn c370_l574_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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))]);
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64(
-            (0.0000000000000000000000000000000000000000039514377070783294f64)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000039514377070783294f64)))));
     result.map(|_| ())
 }
 
@@ -4691,15 +3210,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -4708,55 +3224,40 @@ 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))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.abs", &[Value::F64(f64::from_bits(9218868441285556843))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.abs", &[Value::F64(f64::from_bits(18442240478140332651))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -4765,15 +3266,12 @@ 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))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -4782,239 +3280,152 @@ 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))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.neg", &[Value::F64(f64::from_bits(9218868441285556843))]);
     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);
-    }
+                                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))],
-    );
+    let result = instance.call("f64.neg", &[Value::F64(f64::from_bits(18442240478140332651))]);
     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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(2139156962)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(2139156962)), Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(2143289344)),
-        ],
-    );
+    let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(4286640610)), Value::F32(f32::from_bits(2143289344))]);
     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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(4290772992)),
-        ],
-    );
+    let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(4286640610)), Value::F32(f32::from_bits(4290772992))]);
     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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(9218868441285556843)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(9218868441285556843)), Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-        ],
-    );
+    let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(18442240478140332651)), Value::F64(f64::from_bits(9221120237041090560))]);
     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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(18444492273895866368)),
-        ],
-    );
+    let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(18442240478140332651)), Value::F64(f64::from_bits(18444492273895866368))]);
     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);
-    }
+                                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(|_| ())
 }
 
@@ -5285,14 +3696,8 @@ fn c429_l662_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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))],
-    );
-    assert_eq!(
-        result,
-        Ok(Some(Value::F64((81129638414606670000000000000000.0f64))))
-    );
+    let result = instance.call("f64.nearest", &[Value::F64((81129638414606670000000000000000.0f64))]);
+    assert_eq!(result, Ok(Some(Value::F64((81129638414606670000000000000000.0f64)))));
     result.map(|_| ())
 }
 
diff --git a/lib/runtime/tests/spectests/forward.rs b/lib/runtime/tests/spectests/forward.rs
index a7f1cc842..0d46031fb 100644
--- a/lib/runtime/tests/spectests/forward.rs
+++ b/lib/runtime/tests/spectests/forward.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (func (;0;) (type 0) (param i32) (result i32)
@@ -46,11 +50,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
diff --git a/lib/runtime/tests/spectests/func.rs b/lib/runtime/tests/spectests/func.rs
index 40746aded..81289d70a 100644
--- a/lib/runtime/tests/spectests/func.rs
+++ b/lib/runtime/tests/spectests/func.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func))
@@ -327,11 +331,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -366,14 +367,7 @@ fn c3_l173_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("type-use-4", &[Value::I32(1 as i32), Value::F64((1.0f64)), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -397,14 +391,7 @@ fn c6_l179_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("type-use-7", &[Value::I32(1 as i32), Value::F64((1.0f64)), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
     result.map(|_| ())
 }
@@ -484,10 +471,7 @@ fn c16_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -495,10 +479,7 @@ fn c17_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -506,10 +487,7 @@ fn c18_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((3.0f32))],
-    );
+    let result = instance.call("param-first-f32", &[Value::F32((2.0f32)), Value::F32((3.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((2.0f32)))));
     result.map(|_| ())
 }
@@ -517,10 +495,7 @@ fn c19_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((3.0f64))],
-    );
+    let result = instance.call("param-first-f64", &[Value::F64((2.0f64)), Value::F64((3.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((2.0f64)))));
     result.map(|_| ())
 }
@@ -528,10 +503,7 @@ fn c20_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -539,10 +511,7 @@ fn c21_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -550,10 +519,7 @@ fn c22_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F32((3.0f32))],
-    );
+    let result = instance.call("param-second-f32", &[Value::F32((2.0f32)), Value::F32((3.0f32))]);
     assert_eq!(result, Ok(Some(Value::F32((3.0f32)))));
     result.map(|_| ())
 }
@@ -561,10 +527,7 @@ fn c23_l214_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)), Value::F64((3.0f64))],
-    );
+    let result = instance.call("param-second-f64", &[Value::F64((2.0f64)), Value::F64((3.0f64))]);
     assert_eq!(result, Ok(Some(Value::F64((3.0f64)))));
     result.map(|_| ())
 }
@@ -572,17 +535,7 @@ fn c24_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::I32(2 as i32),
-            Value::I64(3 as i64),
-            Value::I32(4 as i32),
-            Value::F64((5.5f64)),
-            Value::I32(6 as i32),
-        ],
-    );
+    let result = instance.call("param-mixed", &[Value::F32((1.0f32)), Value::I32(2 as i32), Value::I64(3 as i64), Value::I32(4 as i32), Value::F64((5.5f64)), Value::I32(6 as i32)]);
     assert_eq!(result, Ok(Some(Value::F64((5.5f64)))));
     result.map(|_| ())
 }
@@ -1016,7 +969,7 @@ fn test_module_1() {
     c68_l283_action_invoke(&mut instance);
     c69_l284_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32)))
       (type (;1;) (func (result f64)))
@@ -1034,11 +987,8 @@ fn create_module_2() -> Box<Instance> {
         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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -1049,11 +999,7 @@ fn start_module_2(instance: &mut Instance) {
 // 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 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");
 }
@@ -1066,7 +1012,7 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func))
@@ -1147,11 +1093,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -1194,178 +1137,87 @@ fn c76_l381_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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");
 }
@@ -1373,10 +1225,7 @@ fn c87_l461_assert_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 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");
 }
@@ -1384,10 +1233,7 @@ fn c88_l465_assert_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 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");
 }
@@ -1395,10 +1241,7 @@ fn c89_l469_assert_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 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");
 }
@@ -1406,10 +1249,7 @@ fn c90_l477_assert_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 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");
 }
@@ -1417,10 +1257,7 @@ fn c91_l481_assert_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 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");
 }
@@ -1428,10 +1265,7 @@ fn c92_l485_assert_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 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");
 }
@@ -1439,10 +1273,7 @@ fn c93_l493_assert_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 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");
 }
@@ -1450,9 +1281,7 @@ fn c94_l497_assert_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 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");
 }
@@ -1460,9 +1289,7 @@ fn c95_l506_assert_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 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");
 }
@@ -1470,9 +1297,7 @@ fn c96_l510_assert_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 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");
 }
@@ -1480,9 +1305,7 @@ fn c97_l514_assert_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 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");
 }
@@ -1490,9 +1313,7 @@ fn c98_l518_assert_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 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");
 }
@@ -1500,9 +1321,7 @@ fn c99_l523_assert_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 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");
 }
@@ -1510,10 +1329,7 @@ fn c100_l529_assert_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 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");
 }
@@ -1521,9 +1337,7 @@ fn c101_l535_assert_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 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");
 }
@@ -1531,9 +1345,7 @@ fn c102_l542_assert_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 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");
 }
@@ -1541,10 +1353,7 @@ fn c103_l548_assert_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 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");
 }
@@ -1552,10 +1361,7 @@ fn c104_l554_assert_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 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");
 }
@@ -1563,10 +1369,7 @@ fn c105_l561_assert_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 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");
 }
@@ -1574,10 +1377,7 @@ fn c106_l567_assert_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 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");
 }
@@ -1585,10 +1385,7 @@ fn c107_l573_assert_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 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");
 }
@@ -1596,9 +1393,7 @@ fn c108_l579_assert_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 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");
 }
@@ -1606,10 +1401,7 @@ fn c109_l586_assert_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 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");
 }
@@ -1617,10 +1409,7 @@ fn c110_l592_assert_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 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");
 }
@@ -1628,10 +1417,7 @@ fn c111_l598_assert_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 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");
 }
@@ -1639,10 +1425,7 @@ fn c112_l604_assert_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 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");
 }
@@ -1650,10 +1433,7 @@ fn c113_l610_assert_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 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");
 }
@@ -1661,10 +1441,7 @@ fn c114_l617_assert_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 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");
 }
@@ -1672,10 +1449,7 @@ fn c115_l623_assert_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 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");
 }
@@ -1683,87 +1457,49 @@ fn c116_l629_assert_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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/func_ptrs.rs b/lib/runtime/tests/spectests/func_ptrs.rs
index ad33d5afd..c6e833130 100644
--- a/lib/runtime/tests/spectests/func_ptrs.rs
+++ b/lib/runtime/tests/spectests/func_ptrs.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func))
@@ -46,11 +50,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -86,7 +87,7 @@ fn c3_l29_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -101,10 +102,7 @@ fn c5_l32_assert_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 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");
 }
@@ -112,9 +110,7 @@ fn c6_l33_assert_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 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");
 }
@@ -122,9 +118,7 @@ fn c7_l36_assert_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 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");
 }
@@ -132,9 +126,7 @@ fn c8_l40_assert_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 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");
 }
@@ -150,10 +142,7 @@ fn c10_l48_assert_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 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");
 }
@@ -170,7 +159,7 @@ fn test_module_1() {
     c3_l29_action_invoke(&mut instance);
     c4_l30_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func (result i32)))
@@ -197,11 +186,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -269,14 +255,14 @@ fn c19_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c20_l78_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -284,14 +270,14 @@ fn c20_l78_assert_trap() {
 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);
+    let result = c21_l79_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -299,14 +285,14 @@ fn c21_l79_assert_trap() {
 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);
+    let result = c22_l80_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -370,14 +356,14 @@ fn c29_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c30_l89_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -385,14 +371,14 @@ fn c30_l89_assert_trap() {
 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);
+    let result = c31_l90_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -400,14 +386,14 @@ fn c31_l90_assert_trap() {
 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);
+    let result = c32_l91_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -433,7 +419,7 @@ fn test_module_2() {
     c28_l87_action_invoke(&mut instance);
     c29_l88_action_invoke(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func (param i32) (result i32)))
@@ -449,11 +435,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
diff --git a/lib/runtime/tests/spectests/get_local.rs b/lib/runtime/tests/spectests/get_local.rs
index 5867e8fa0..5948108cc 100644
--- a/lib/runtime/tests/spectests/get_local.rs
+++ b/lib/runtime/tests/spectests/get_local.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func (result i64)))
@@ -120,11 +124,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -199,16 +200,7 @@ fn c8_l72_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((3.3f64)),
-            Value::I32(4 as i32),
-            Value::I32(5 as i32),
-        ],
-    );
+    let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]);
     assert_eq!(result, Ok(None));
     result.map(|_| ())
 }
@@ -216,16 +208,7 @@ fn c9_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((3.3f64)),
-            Value::I32(4 as i32),
-            Value::I32(5 as i32),
-        ],
-    );
+    let result = instance.call("read", &[Value::I64(1 as i64), Value::F32((2.0f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]);
     assert_eq!(result, Ok(Some(Value::F64((34.8f64)))));
     result.map(|_| ())
 }
@@ -233,10 +216,7 @@ fn c10_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -244,10 +224,7 @@ fn c11_l91_assert_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 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");
 }
@@ -255,10 +232,7 @@ fn c12_l95_assert_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 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");
 }
@@ -266,10 +240,7 @@ fn c13_l99_assert_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 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");
 }
@@ -277,10 +248,7 @@ fn c14_l107_assert_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 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");
 }
@@ -288,10 +256,7 @@ fn c15_l111_assert_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 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");
 }
@@ -299,10 +264,7 @@ fn c16_l115_assert_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 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");
 }
@@ -310,10 +272,7 @@ fn c17_l123_assert_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 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");
 }
@@ -321,10 +280,7 @@ fn c18_l127_assert_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 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");
 }
@@ -332,10 +288,7 @@ fn c19_l132_assert_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 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");
 }
@@ -343,10 +296,7 @@ fn c20_l136_assert_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 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");
 }
@@ -354,10 +304,7 @@ fn c21_l141_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/globals.rs b/lib/runtime/tests/spectests/globals.rs
index cd25412ed..56e8a5537 100644
--- a/lib/runtime/tests/spectests/globals.rs
+++ b/lib/runtime/tests/spectests/globals.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 4
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func (result i32)))
@@ -271,11 +275,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -535,14 +536,14 @@ fn c31_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c32_l222_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -661,10 +662,7 @@ fn c46_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -672,9 +670,7 @@ fn c47_l244_assert_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 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");
 }
@@ -690,9 +686,7 @@ fn c49_l261_assert_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 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");
 }
@@ -716,9 +710,7 @@ fn c52_l276_assert_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 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");
 }
@@ -726,9 +718,7 @@ fn c53_l281_assert_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 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");
 }
@@ -736,9 +726,7 @@ fn c54_l286_assert_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 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");
 }
@@ -762,9 +750,7 @@ fn c57_l302_assert_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 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");
 }
@@ -822,7 +808,7 @@ fn test_module_1() {
     c45_l240_action_invoke(&mut instance);
     c46_l241_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (import \"spectest\" \"global_i32\" (global (;0;) i32))
@@ -835,11 +821,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -866,29 +849,17 @@ fn c61_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 348
@@ -901,16 +872,13 @@ fn test_module_2() {
     c60_l318_action_invoke(&mut instance);
     c61_l319_action_invoke(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -921,27 +889,17 @@ fn start_module_3(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/i32_.rs b/lib/runtime/tests/spectests/i32_.rs
index 2a4730bd1..1e96b819e 100644
--- a/lib/runtime/tests/spectests/i32_.rs
+++ b/lib/runtime/tests/spectests/i32_.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func (param i32) (result i32)))
@@ -162,11 +166,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -209,10 +210,7 @@ fn c4_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -220,10 +218,7 @@ fn c5_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -231,13 +226,7 @@ fn c6_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -245,10 +234,7 @@ fn c7_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -280,10 +266,7 @@ fn c11_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -291,10 +274,7 @@ fn c12_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -302,13 +282,7 @@ fn c13_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -316,10 +290,7 @@ fn c14_l49_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -351,10 +322,7 @@ fn c18_l54_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -362,10 +330,7 @@ fn c19_l55_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -373,10 +338,7 @@ fn c20_l56_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -384,10 +346,7 @@ fn c21_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -395,10 +354,7 @@ fn c22_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -406,10 +362,7 @@ fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -418,14 +371,14 @@ fn c24_l60_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c25_l62_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -433,32 +386,29 @@ fn c25_l62_assert_trap() {
 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);
+    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)],
-    );
-
+    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);
+    let result = c27_l64_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -497,10 +447,7 @@ fn c31_l68_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -508,10 +455,7 @@ fn c32_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -600,14 +544,14 @@ fn c43_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c44_l82_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -615,14 +559,14 @@ fn c44_l82_assert_trap() {
 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);
+    let result = c45_l83_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -653,10 +597,7 @@ fn c48_l86_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -664,10 +605,7 @@ fn c49_l87_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -675,10 +613,7 @@ fn c50_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -686,10 +621,7 @@ fn c51_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -754,14 +686,14 @@ fn c59_l97_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c60_l99_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -769,24 +701,21 @@ fn c60_l99_assert_trap() {
 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);
+    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)],
-    );
+    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(|_| ())
 }
@@ -826,10 +755,7 @@ fn c66_l105_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -837,10 +763,7 @@ fn c67_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -848,10 +771,7 @@ fn c68_l107_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -940,14 +860,14 @@ fn c79_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c80_l120_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -955,14 +875,14 @@ fn c80_l120_assert_trap() {
 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);
+    let result = c81_l121_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -993,10 +913,7 @@ fn c84_l124_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1004,10 +921,7 @@ fn c85_l125_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1015,10 +929,7 @@ fn c86_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1026,10 +937,7 @@ fn c87_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1125,13 +1033,7 @@ fn c99_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1139,10 +1041,7 @@ fn c100_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1150,10 +1049,7 @@ fn c101_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1201,13 +1097,7 @@ fn c107_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1215,10 +1105,7 @@ fn c108_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1226,10 +1113,7 @@ fn c109_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1277,13 +1161,7 @@ fn c115_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1291,10 +1169,7 @@ fn c116_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1302,10 +1177,7 @@ fn c117_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1313,10 +1185,7 @@ fn c118_l161_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1324,10 +1193,7 @@ fn c119_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1359,10 +1225,7 @@ fn c123_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1378,10 +1241,7 @@ fn c125_l169_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1389,10 +1249,7 @@ fn c126_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1432,10 +1289,7 @@ fn c131_l175_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1467,10 +1321,7 @@ fn c135_l180_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1478,10 +1329,7 @@ fn c136_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1489,10 +1337,7 @@ fn c137_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1524,10 +1369,7 @@ fn c141_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1535,10 +1377,7 @@ fn c142_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1546,10 +1385,7 @@ fn c143_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1581,10 +1417,7 @@ fn c147_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1592,10 +1425,7 @@ fn c148_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1627,10 +1457,7 @@ fn c152_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1638,10 +1465,7 @@ fn c153_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1649,10 +1473,7 @@ fn c154_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1684,10 +1505,7 @@ fn c158_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1695,10 +1513,7 @@ fn c159_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1706,10 +1521,7 @@ fn c160_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1741,10 +1553,7 @@ fn c164_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1752,10 +1561,7 @@ fn c165_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1795,10 +1601,7 @@ fn c170_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1806,10 +1609,7 @@ fn c171_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1817,10 +1617,7 @@ fn c172_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1836,10 +1633,7 @@ fn c174_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1847,10 +1641,7 @@ fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1858,13 +1649,7 @@ fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1880,10 +1665,7 @@ fn c178_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1923,10 +1705,7 @@ fn c183_l231_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1942,10 +1721,7 @@ fn c185_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1961,10 +1737,7 @@ fn c187_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1972,10 +1745,7 @@ fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1983,13 +1753,7 @@ fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2005,10 +1769,7 @@ fn c191_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2256,13 +2017,7 @@ fn c222_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2270,10 +2025,7 @@ fn c223_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2305,10 +2057,7 @@ fn c227_l280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2316,10 +2065,7 @@ fn c228_l281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2327,10 +2073,7 @@ fn c229_l282_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2338,10 +2081,7 @@ fn c230_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2349,13 +2089,7 @@ fn c231_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2363,13 +2097,7 @@ fn c232_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2401,13 +2129,7 @@ fn c236_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2415,10 +2137,7 @@ fn c237_l291_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2450,10 +2169,7 @@ fn c241_l295_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2461,10 +2177,7 @@ fn c242_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2472,10 +2185,7 @@ fn c243_l297_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2483,10 +2193,7 @@ fn c244_l298_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2494,13 +2201,7 @@ fn c245_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2508,13 +2209,7 @@ fn c246_l300_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2546,13 +2241,7 @@ fn c250_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2560,10 +2249,7 @@ fn c251_l306_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2595,10 +2281,7 @@ fn c255_l310_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2606,10 +2289,7 @@ fn c256_l311_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2617,10 +2297,7 @@ fn c257_l312_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2628,10 +2305,7 @@ fn c258_l313_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2639,13 +2313,7 @@ fn c259_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2653,13 +2321,7 @@ fn c260_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2691,13 +2353,7 @@ fn c264_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2705,10 +2361,7 @@ fn c265_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2740,10 +2393,7 @@ fn c269_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2751,10 +2401,7 @@ fn c270_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2762,10 +2409,7 @@ fn c271_l327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2773,10 +2417,7 @@ fn c272_l328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2784,13 +2425,7 @@ fn c273_l329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2798,13 +2433,7 @@ fn c274_l330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2836,13 +2465,7 @@ fn c278_l335_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2850,10 +2473,7 @@ fn c279_l336_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2885,10 +2505,7 @@ fn c283_l340_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2896,10 +2513,7 @@ fn c284_l341_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2907,10 +2521,7 @@ fn c285_l342_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2918,10 +2529,7 @@ fn c286_l343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2929,13 +2537,7 @@ fn c287_l344_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2943,13 +2545,7 @@ fn c288_l345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2981,13 +2577,7 @@ fn c292_l350_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2995,10 +2585,7 @@ fn c293_l351_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3030,10 +2617,7 @@ fn c297_l355_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3041,10 +2625,7 @@ fn c298_l356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3052,10 +2633,7 @@ fn c299_l357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3063,10 +2641,7 @@ fn c300_l358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3074,13 +2649,7 @@ fn c301_l359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3088,13 +2657,7 @@ fn c302_l360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3126,13 +2689,7 @@ fn c306_l365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3140,10 +2697,7 @@ fn c307_l366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3175,10 +2729,7 @@ fn c311_l370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3186,10 +2737,7 @@ fn c312_l371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3197,10 +2745,7 @@ fn c313_l372_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3208,10 +2753,7 @@ fn c314_l373_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3219,13 +2761,7 @@ fn c315_l374_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3233,13 +2769,7 @@ fn c316_l375_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3271,13 +2801,7 @@ fn c320_l380_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3285,10 +2809,7 @@ fn c321_l381_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3320,10 +2841,7 @@ fn c325_l385_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3331,10 +2849,7 @@ fn c326_l386_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3342,10 +2857,7 @@ fn c327_l387_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3353,10 +2865,7 @@ fn c328_l388_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3364,13 +2873,7 @@ fn c329_l389_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3378,13 +2881,7 @@ fn c330_l390_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3416,13 +2913,7 @@ fn c334_l395_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3430,10 +2921,7 @@ fn c335_l396_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3465,10 +2953,7 @@ fn c339_l400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3476,10 +2961,7 @@ fn c340_l401_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3487,10 +2969,7 @@ fn c341_l402_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3498,10 +2977,7 @@ fn c342_l403_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3509,13 +2985,7 @@ fn c343_l404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3523,13 +2993,7 @@ fn c344_l405_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3561,13 +3025,7 @@ fn c348_l410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3575,10 +3033,7 @@ fn c349_l411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3610,10 +3065,7 @@ fn c353_l415_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3621,10 +3073,7 @@ fn c354_l416_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3632,10 +3081,7 @@ fn c355_l417_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3643,10 +3089,7 @@ fn c356_l418_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -3654,13 +3097,7 @@ fn c357_l419_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3668,13 +3105,7 @@ fn c358_l420_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
diff --git a/lib/runtime/tests/spectests/i64_.rs b/lib/runtime/tests/spectests/i64_.rs
index 32c5d0a89..4bd4c20de 100644
--- a/lib/runtime/tests/spectests/i64_.rs
+++ b/lib/runtime/tests/spectests/i64_.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i64 i64) (result i64)))
       (type (;1;) (func (param i64) (result i64)))
@@ -164,11 +168,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -211,10 +212,7 @@ fn c4_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -222,13 +220,7 @@ fn c5_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -236,13 +228,7 @@ fn c6_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -250,10 +236,7 @@ fn c7_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -285,13 +268,7 @@ fn c11_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -299,13 +276,7 @@ fn c12_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -313,13 +284,7 @@ fn c13_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -327,10 +292,7 @@ fn c14_l49_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -362,13 +324,7 @@ fn c18_l54_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -376,13 +332,7 @@ fn c19_l55_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -390,13 +340,7 @@ fn c20_l56_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -404,13 +348,7 @@ fn c21_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -418,13 +356,7 @@ fn c22_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -432,13 +364,7 @@ fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -447,14 +373,14 @@ fn c24_l60_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c25_l62_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -462,35 +388,29 @@ fn c25_l62_assert_trap() {
 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);
+    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),
-        ],
-    );
-
+    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);
+    let result = c27_l64_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -529,13 +449,7 @@ fn c31_l68_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -543,13 +457,7 @@ fn c32_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -638,14 +546,14 @@ fn c43_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c44_l82_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -653,14 +561,14 @@ fn c44_l82_assert_trap() {
 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);
+    let result = c45_l83_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -691,13 +599,7 @@ fn c48_l86_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -705,13 +607,7 @@ fn c49_l87_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -719,13 +615,7 @@ fn c50_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -733,13 +623,7 @@ fn c51_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -804,14 +688,14 @@ fn c59_l97_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c60_l99_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -819,27 +703,21 @@ fn c60_l99_assert_trap() {
 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);
+    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),
-        ],
-    );
+    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(|_| ())
 }
@@ -879,13 +757,7 @@ fn c66_l105_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -893,13 +765,7 @@ fn c67_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -907,13 +773,7 @@ fn c68_l107_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1002,14 +862,14 @@ fn c79_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c80_l120_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1017,14 +877,14 @@ fn c80_l120_assert_trap() {
 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);
+    let result = c81_l121_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1055,13 +915,7 @@ fn c84_l124_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1069,13 +923,7 @@ fn c85_l125_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1083,13 +931,7 @@ fn c86_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1097,13 +939,7 @@ fn c87_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1199,13 +1035,7 @@ fn c99_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1213,13 +1043,7 @@ fn c100_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1227,10 +1051,7 @@ fn c101_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1278,13 +1099,7 @@ fn c107_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1292,13 +1107,7 @@ fn c108_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1306,10 +1115,7 @@ fn c109_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1357,13 +1163,7 @@ fn c115_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1371,13 +1171,7 @@ fn c116_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1385,13 +1179,7 @@ fn c117_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1399,13 +1187,7 @@ fn c118_l161_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1413,10 +1195,7 @@ fn c119_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1448,10 +1227,7 @@ fn c123_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1467,13 +1243,7 @@ fn c125_l169_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1481,10 +1251,7 @@ fn c126_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1524,10 +1291,7 @@ fn c131_l175_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1559,10 +1323,7 @@ fn c135_l180_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1570,13 +1331,7 @@ fn c136_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1584,10 +1339,7 @@ fn c137_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1619,10 +1371,7 @@ fn c141_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1630,13 +1379,7 @@ fn c142_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1644,13 +1387,7 @@ fn c143_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1682,13 +1419,7 @@ fn c147_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1696,13 +1427,7 @@ fn c148_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1734,10 +1459,7 @@ fn c152_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1745,13 +1467,7 @@ fn c153_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1759,10 +1475,7 @@ fn c154_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1794,10 +1507,7 @@ fn c158_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1805,13 +1515,7 @@ fn c159_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1819,13 +1523,7 @@ fn c160_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1857,13 +1555,7 @@ fn c164_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1871,13 +1563,7 @@ fn c165_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1917,13 +1603,7 @@ fn c170_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1931,10 +1611,7 @@ fn c171_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1942,13 +1619,7 @@ fn c172_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1956,13 +1627,7 @@ fn c173_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1970,13 +1635,7 @@ fn c174_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1984,13 +1643,7 @@ fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1998,13 +1651,7 @@ fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2020,13 +1667,7 @@ fn c178_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2066,13 +1707,7 @@ fn c183_l231_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2080,10 +1715,7 @@ fn c184_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -2091,13 +1723,7 @@ fn c185_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2105,13 +1731,7 @@ fn c186_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2119,13 +1739,7 @@ fn c187_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2133,13 +1747,7 @@ fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2147,13 +1755,7 @@ fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2169,13 +1771,7 @@ fn c191_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2423,13 +2019,7 @@ fn c222_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2437,13 +2027,7 @@ fn c223_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2475,13 +2059,7 @@ fn c227_l280_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2489,13 +2067,7 @@ fn c228_l281_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2503,13 +2075,7 @@ fn c229_l282_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2517,13 +2083,7 @@ fn c230_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2531,13 +2091,7 @@ fn c231_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2545,13 +2099,7 @@ fn c232_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2583,13 +2131,7 @@ fn c236_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2597,13 +2139,7 @@ fn c237_l291_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2635,13 +2171,7 @@ fn c241_l295_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2649,13 +2179,7 @@ fn c242_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2663,13 +2187,7 @@ fn c243_l297_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2677,13 +2195,7 @@ fn c244_l298_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2691,13 +2203,7 @@ fn c245_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2705,13 +2211,7 @@ fn c246_l300_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2743,13 +2243,7 @@ fn c250_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2757,13 +2251,7 @@ fn c251_l306_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2795,13 +2283,7 @@ fn c255_l310_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2809,13 +2291,7 @@ fn c256_l311_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2823,13 +2299,7 @@ fn c257_l312_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2837,13 +2307,7 @@ fn c258_l313_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2851,13 +2315,7 @@ fn c259_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2865,13 +2323,7 @@ fn c260_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2903,13 +2355,7 @@ fn c264_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2917,13 +2363,7 @@ fn c265_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2955,13 +2395,7 @@ fn c269_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2969,13 +2403,7 @@ fn c270_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2983,13 +2411,7 @@ fn c271_l327_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -2997,13 +2419,7 @@ fn c272_l328_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3011,13 +2427,7 @@ fn c273_l329_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3025,13 +2435,7 @@ fn c274_l330_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3063,13 +2467,7 @@ fn c278_l335_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3077,13 +2475,7 @@ fn c279_l336_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3115,13 +2507,7 @@ fn c283_l340_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3129,13 +2515,7 @@ fn c284_l341_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3143,13 +2523,7 @@ fn c285_l342_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3157,13 +2531,7 @@ fn c286_l343_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3171,13 +2539,7 @@ fn c287_l344_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3185,13 +2547,7 @@ fn c288_l345_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3223,13 +2579,7 @@ fn c292_l350_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3237,13 +2587,7 @@ fn c293_l351_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3275,13 +2619,7 @@ fn c297_l355_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3289,13 +2627,7 @@ fn c298_l356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3303,13 +2635,7 @@ fn c299_l357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3317,13 +2643,7 @@ fn c300_l358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3331,13 +2651,7 @@ fn c301_l359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3345,13 +2659,7 @@ fn c302_l360_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3383,13 +2691,7 @@ fn c306_l365_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3397,13 +2699,7 @@ fn c307_l366_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3435,13 +2731,7 @@ fn c311_l370_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3449,13 +2739,7 @@ fn c312_l371_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3463,13 +2747,7 @@ fn c313_l372_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3477,13 +2755,7 @@ fn c314_l373_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3491,13 +2763,7 @@ fn c315_l374_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3505,13 +2771,7 @@ fn c316_l375_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3543,13 +2803,7 @@ fn c320_l380_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3557,13 +2811,7 @@ fn c321_l381_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3595,13 +2843,7 @@ fn c325_l385_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3609,13 +2851,7 @@ fn c326_l386_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3623,13 +2859,7 @@ fn c327_l387_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3637,13 +2867,7 @@ fn c328_l388_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3651,13 +2875,7 @@ fn c329_l389_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3665,13 +2883,7 @@ fn c330_l390_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3703,13 +2915,7 @@ fn c334_l395_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3717,13 +2923,7 @@ fn c335_l396_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3755,13 +2955,7 @@ fn c339_l400_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3769,13 +2963,7 @@ fn c340_l401_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3783,13 +2971,7 @@ fn c341_l402_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3797,13 +2979,7 @@ fn c342_l403_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3811,13 +2987,7 @@ fn c343_l404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3825,13 +2995,7 @@ fn c344_l405_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3863,13 +3027,7 @@ fn c348_l410_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3877,13 +3035,7 @@ fn c349_l411_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3915,13 +3067,7 @@ fn c353_l415_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3929,13 +3075,7 @@ fn c354_l416_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3943,13 +3083,7 @@ fn c355_l417_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3957,13 +3091,7 @@ fn c356_l418_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3971,13 +3099,7 @@ fn c357_l419_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -3985,13 +3107,7 @@ fn c358_l420_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
diff --git a/lib/runtime/tests/spectests/if_.rs b/lib/runtime/tests/spectests/if_.rs
index d5388e1f8..4b610d7f2 100644
--- a/lib/runtime/tests/spectests/if_.rs
+++ b/lib/runtime/tests/spectests/if_.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func))
@@ -637,11 +641,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -1029,14 +1030,14 @@ fn c47_l439_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c48_l440_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1243,10 +1244,7 @@ fn c73_l476_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1254,10 +1252,7 @@ fn c74_l478_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1265,10 +1260,7 @@ fn c75_l479_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1276,10 +1268,7 @@ fn c76_l480_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1303,10 +1292,7 @@ fn c79_l484_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1314,10 +1300,7 @@ fn c80_l486_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1325,10 +1308,7 @@ fn c81_l487_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1336,10 +1316,7 @@ fn c82_l488_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1387,10 +1364,7 @@ fn c88_l496_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -1398,10 +1372,7 @@ fn c89_l499_assert_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 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");
 }
@@ -1409,10 +1380,7 @@ fn c90_l503_assert_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 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");
 }
@@ -1420,10 +1388,7 @@ fn c91_l507_assert_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 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");
 }
@@ -1431,10 +1396,7 @@ fn c92_l511_assert_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 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");
 }
@@ -1442,10 +1404,7 @@ fn c93_l516_assert_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 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");
 }
@@ -1453,10 +1412,7 @@ fn c94_l520_assert_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 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");
 }
@@ -1464,10 +1420,7 @@ fn c95_l524_assert_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 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");
 }
@@ -1475,10 +1428,7 @@ fn c96_l528_assert_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 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");
 }
@@ -1486,10 +1436,7 @@ fn c97_l533_assert_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 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");
 }
@@ -1497,10 +1444,7 @@ fn c98_l539_assert_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 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");
 }
@@ -1508,10 +1452,7 @@ fn c99_l545_assert_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 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");
 }
@@ -1519,10 +1460,7 @@ fn c100_l551_assert_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 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");
 }
@@ -1530,10 +1468,7 @@ fn c101_l558_assert_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 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");
 }
@@ -1541,10 +1476,7 @@ fn c102_l564_assert_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 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");
 }
@@ -1552,10 +1484,7 @@ fn c103_l570_assert_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 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");
 }
@@ -1563,10 +1492,7 @@ fn c104_l576_assert_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 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");
 }
@@ -1574,10 +1500,7 @@ fn c105_l583_assert_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 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");
 }
@@ -1585,10 +1508,7 @@ fn c106_l589_assert_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 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");
 }
@@ -1596,10 +1516,7 @@ fn c107_l595_assert_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 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");
 }
@@ -1607,10 +1524,7 @@ fn c108_l602_assert_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 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");
 }
@@ -1618,10 +1532,7 @@ fn c109_l608_assert_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 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");
 }
@@ -1629,10 +1540,7 @@ fn c110_l614_assert_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 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");
 }
@@ -1640,10 +1548,7 @@ fn c111_l620_assert_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 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");
 }
@@ -1651,10 +1556,7 @@ fn c112_l627_assert_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 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");
 }
@@ -1662,10 +1564,7 @@ fn c113_l637_assert_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 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");
 }
@@ -1673,10 +1572,7 @@ fn c114_l647_assert_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 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");
 }
@@ -1684,10 +1580,7 @@ fn c115_l658_assert_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 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");
 }
@@ -1695,10 +1588,7 @@ fn c116_l664_assert_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 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");
 }
@@ -1706,10 +1596,7 @@ fn c117_l670_assert_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 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");
 }
@@ -1717,10 +1604,7 @@ fn c118_l679_assert_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 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");
 }
@@ -1728,10 +1612,7 @@ fn c119_l688_assert_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 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");
 }
@@ -1739,10 +1620,7 @@ fn c120_l697_assert_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 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");
 }
@@ -1750,10 +1628,7 @@ fn c121_l707_assert_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 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");
 }
@@ -1761,139 +1636,81 @@ fn c122_l716_assert_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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/int_exprs.rs b/lib/runtime/tests/spectests/int_exprs.rs
index e08d15e08..2ed5cf810 100644
--- a/lib/runtime/tests/spectests/int_exprs.rs
+++ b/lib/runtime/tests/spectests/int_exprs.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 6
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func (param i64 i64) (result i32)))
@@ -57,11 +61,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -72,10 +73,7 @@ fn start_module_1(instance: &mut Instance) {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -83,10 +81,7 @@ fn c1_l18_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -94,10 +89,7 @@ fn c2_l19_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -105,10 +97,7 @@ fn c3_l20_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -125,7 +114,7 @@ fn test_module_1() {
     c3_l20_action_invoke(&mut instance);
     c4_l21_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i64) (result i64)))
       (func (;0;) (type 0) (param i64) (result i64)
@@ -135,11 +124,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -150,10 +136,7 @@ fn start_module_2(instance: &mut Instance) {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -161,10 +144,7 @@ fn c6_l30_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -179,7 +159,7 @@ fn test_module_2() {
     c6_l30_action_invoke(&mut instance);
     c7_l31_action_invoke(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i64) (result i64)))
       (func (;0;) (type 0) (param i64) (result i64)
@@ -189,11 +169,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -204,10 +181,7 @@ fn start_module_3(instance: &mut Instance) {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -221,7 +195,7 @@ fn test_module_3() {
     start_module_3(&mut instance);
     c9_l40_action_invoke(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -255,11 +229,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -286,10 +257,7 @@ fn c12_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -297,10 +265,7 @@ fn c13_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -317,7 +282,7 @@ fn test_module_4() {
     c13_l58_action_invoke(&mut instance);
     c14_l59_action_invoke(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -351,11 +316,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -407,7 +369,7 @@ fn test_module_5() {
     c18_l77_action_invoke(&mut instance);
     c19_l78_action_invoke(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -441,11 +403,8 @@ fn create_module_6() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -497,7 +456,7 @@ fn test_module_6() {
     c23_l96_action_invoke(&mut instance);
     c24_l97_action_invoke(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -523,11 +482,8 @@ fn create_module_7() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -539,14 +495,14 @@ fn start_module_7(instance: &mut Instance) {
 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);
+    let result = c26_l113_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -554,14 +510,14 @@ fn c26_l113_assert_trap() {
 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);
+    let result = c27_l114_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -569,14 +525,14 @@ fn c27_l114_assert_trap() {
 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);
+    let result = c28_l115_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -584,14 +540,14 @@ fn c28_l115_assert_trap() {
 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);
+    let result = c29_l116_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -603,7 +559,7 @@ fn test_module_7() {
     // We group the calls together
     start_module_7(&mut instance);
 }
-fn create_module_8() -> Box<Instance> {
+fn create_module_8() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -629,11 +585,8 @@ fn create_module_8() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_8(instance: &mut Instance) {
@@ -645,14 +598,14 @@ fn start_module_8(instance: &mut Instance) {
 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);
+    let result = c31_l132_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -660,14 +613,14 @@ fn c31_l132_assert_trap() {
 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);
+    let result = c32_l133_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -675,14 +628,14 @@ fn c32_l133_assert_trap() {
 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);
+    let result = c33_l134_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -690,14 +643,14 @@ fn c33_l134_assert_trap() {
 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);
+    let result = c34_l135_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -709,7 +662,7 @@ fn test_module_8() {
     // We group the calls together
     start_module_8(&mut instance);
 }
-fn create_module_9() -> Box<Instance> {
+fn create_module_9() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -743,11 +696,8 @@ fn create_module_9() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_9(instance: &mut Instance) {
@@ -774,10 +724,7 @@ fn c37_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -785,10 +732,7 @@ fn c38_l153_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -805,7 +749,7 @@ fn test_module_9() {
     c38_l153_action_invoke(&mut instance);
     c39_l154_action_invoke(&mut instance);
 }
-fn create_module_10() -> Box<Instance> {
+fn create_module_10() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -821,11 +765,8 @@ fn create_module_10() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_10(instance: &mut Instance) {
@@ -859,7 +800,7 @@ fn test_module_10() {
     c41_l166_action_invoke(&mut instance);
     c42_l167_action_invoke(&mut instance);
 }
-fn create_module_11() -> Box<Instance> {
+fn create_module_11() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -875,11 +816,8 @@ fn create_module_11() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_11(instance: &mut Instance) {
@@ -913,7 +851,7 @@ fn test_module_11() {
     c44_l179_action_invoke(&mut instance);
     c45_l180_action_invoke(&mut instance);
 }
-fn create_module_12() -> Box<Instance> {
+fn create_module_12() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -939,11 +877,8 @@ fn create_module_12() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_12(instance: &mut Instance) {
@@ -955,14 +890,14 @@ fn start_module_12(instance: &mut Instance) {
 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);
+    let result = c47_l196_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -970,14 +905,14 @@ fn c47_l196_assert_trap() {
 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);
+    let result = c48_l197_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -985,14 +920,14 @@ fn c48_l197_assert_trap() {
 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);
+    let result = c49_l198_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1000,14 +935,14 @@ fn c49_l198_assert_trap() {
 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);
+    let result = c50_l199_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1019,7 +954,7 @@ fn test_module_12() {
     // We group the calls together
     start_module_12(&mut instance);
 }
-fn create_module_13() -> Box<Instance> {
+fn create_module_13() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -1045,11 +980,8 @@ fn create_module_13() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_13(instance: &mut Instance) {
@@ -1137,7 +1069,7 @@ fn test_module_13() {
     c58_l221_action_invoke(&mut instance);
     c59_l222_action_invoke(&mut instance);
 }
-fn create_module_14() -> Box<Instance> {
+fn create_module_14() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -1163,11 +1095,8 @@ fn create_module_14() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_14(instance: &mut Instance) {
@@ -1255,7 +1184,7 @@ fn test_module_14() {
     c67_l244_action_invoke(&mut instance);
     c68_l245_action_invoke(&mut instance);
 }
-fn create_module_15() -> Box<Instance> {
+fn create_module_15() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -1281,11 +1210,8 @@ fn create_module_15() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_15(instance: &mut Instance) {
@@ -1373,7 +1299,7 @@ fn test_module_15() {
     c76_l267_action_invoke(&mut instance);
     c77_l268_action_invoke(&mut instance);
 }
-fn create_module_16() -> Box<Instance> {
+fn create_module_16() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -1399,11 +1325,8 @@ fn create_module_16() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_16(instance: &mut Instance) {
@@ -1491,7 +1414,7 @@ fn test_module_16() {
     c85_l290_action_invoke(&mut instance);
     c86_l291_action_invoke(&mut instance);
 }
-fn create_module_17() -> Box<Instance> {
+fn create_module_17() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -1517,11 +1440,8 @@ fn create_module_17() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_17(instance: &mut Instance) {
@@ -1609,7 +1529,7 @@ fn test_module_17() {
     c94_l313_action_invoke(&mut instance);
     c95_l314_action_invoke(&mut instance);
 }
-fn create_module_18() -> Box<Instance> {
+fn create_module_18() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -1635,11 +1555,8 @@ fn create_module_18() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_18(instance: &mut Instance) {
@@ -1727,7 +1644,7 @@ fn test_module_18() {
     c103_l336_action_invoke(&mut instance);
     c104_l337_action_invoke(&mut instance);
 }
-fn create_module_19() -> Box<Instance> {
+fn create_module_19() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -1743,11 +1660,8 @@ fn create_module_19() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_19(instance: &mut Instance) {
@@ -1759,32 +1673,29 @@ fn start_module_19(instance: &mut Instance) {
 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);
+    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)],
-    );
-
+    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);
+    let result = c107_l350_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
diff --git a/lib/runtime/tests/spectests/int_literals.rs b/lib/runtime/tests/spectests/int_literals.rs
index 9e8f9cd0e..96f6ce227 100644
--- a/lib/runtime/tests/spectests/int_literals.rs
+++ b/lib/runtime/tests/spectests/int_literals.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func (result i64)))
@@ -137,11 +141,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -392,281 +393,161 @@ fn c30_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/labels.rs b/lib/runtime/tests/spectests/labels.rs
index b6cd3f613..26fe475c5 100644
--- a/lib/runtime/tests/spectests/labels.rs
+++ b/lib/runtime/tests/spectests/labels.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func (param i32) (result i32)))
@@ -453,11 +457,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -668,10 +669,7 @@ fn c25_l308_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -679,10 +677,7 @@ fn c26_l311_assert_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 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");
 }
@@ -690,10 +685,7 @@ fn c27_l315_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/left_to_right.rs b/lib/runtime/tests/spectests/left_to_right.rs
index ad68122b6..f40f4d164 100644
--- a/lib/runtime/tests/spectests/left_to_right.rs
+++ b/lib/runtime/tests/spectests/left_to_right.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func (param i64 i64) (result i32)))
@@ -961,11 +965,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
diff --git a/lib/runtime/tests/spectests/loop_.rs b/lib/runtime/tests/spectests/loop_.rs
index 8859be6c3..ec7c0ddec 100644
--- a/lib/runtime/tests/spectests/loop_.rs
+++ b/lib/runtime/tests/spectests/loop_.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func))
@@ -669,11 +673,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -1212,10 +1213,7 @@ fn c66_l383_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -1223,10 +1221,7 @@ fn c67_l386_assert_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 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");
 }
@@ -1234,10 +1229,7 @@ fn c68_l390_assert_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 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");
 }
@@ -1245,10 +1237,7 @@ fn c69_l394_assert_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 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");
 }
@@ -1256,10 +1245,7 @@ fn c70_l398_assert_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 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");
 }
@@ -1267,10 +1253,7 @@ fn c71_l403_assert_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 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");
 }
@@ -1278,10 +1261,7 @@ fn c72_l409_assert_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 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");
 }
@@ -1289,10 +1269,7 @@ fn c73_l415_assert_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 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");
 }
@@ -1300,10 +1277,7 @@ fn c74_l421_assert_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 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");
 }
@@ -1311,28 +1285,17 @@ fn c75_l427_assert_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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 #[test]
diff --git a/lib/runtime/tests/spectests/memory.rs b/lib/runtime/tests/spectests/memory.rs
index 6d82730ae..928df4506 100644
--- a/lib/runtime/tests/spectests/memory.rs
+++ b/lib/runtime/tests/spectests/memory.rs
@@ -5,26 +5,27 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 2
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -40,16 +41,13 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -65,16 +63,13 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -90,16 +85,13 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -118,10 +110,7 @@ fn c4_l7_assert_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 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");
 }
@@ -134,7 +123,7 @@ fn test_module_4() {
     // We group the calls together
     start_module_4(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (func (;0;) (type 0) (result i32)
@@ -144,11 +133,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -173,7 +159,7 @@ fn test_module_5() {
     start_module_5(&mut instance);
     c7_l11_action_invoke(&mut instance);
 }
-fn create_module_6() -> Box<Instance> {
+fn create_module_6() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (func (;0;) (type 0) (result i32)
@@ -183,11 +169,8 @@ fn create_module_6() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_6(instance: &mut Instance) {
@@ -212,7 +195,7 @@ fn test_module_6() {
     start_module_6(&mut instance);
     c9_l13_action_invoke(&mut instance);
 }
-fn create_module_7() -> Box<Instance> {
+fn create_module_7() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (func (;0;) (type 0) (result i32)
@@ -222,11 +205,8 @@ fn create_module_7() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_7(instance: &mut Instance) {
@@ -269,10 +249,7 @@ fn c14_l19_assert_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 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");
 }
@@ -280,10 +257,7 @@ fn c15_l22_assert_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 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");
 }
@@ -291,10 +265,7 @@ fn c16_l26_assert_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 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");
 }
@@ -302,10 +273,7 @@ fn c17_l30_assert_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 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");
 }
@@ -313,9 +281,7 @@ fn c18_l34_assert_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 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");
 }
@@ -323,10 +289,7 @@ fn c19_l38_assert_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 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");
 }
@@ -350,9 +313,7 @@ fn c22_l52_assert_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 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");
 }
@@ -360,9 +321,7 @@ fn c23_l56_assert_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 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");
 }
@@ -378,9 +337,7 @@ fn c25_l64_assert_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 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");
 }
@@ -388,9 +345,7 @@ fn c26_l68_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/memory_grow.rs b/lib/runtime/tests/spectests/memory_grow.rs
index 43e112683..487a88981 100644
--- a/lib/runtime/tests/spectests/memory_grow.rs
+++ b/lib/runtime/tests/spectests/memory_grow.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func))
@@ -48,11 +52,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -72,14 +73,14 @@ fn c1_l14_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c2_l15_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -87,14 +88,14 @@ fn c2_l15_assert_trap() {
 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);
+    let result = c3_l16_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -102,14 +103,14 @@ fn c3_l16_assert_trap() {
 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);
+    let result = c4_l17_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -117,14 +118,14 @@ fn c4_l17_assert_trap() {
 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);
+    let result = c5_l18_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -172,14 +173,14 @@ fn c10_l23_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c11_l24_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -187,14 +188,14 @@ fn c11_l24_assert_trap() {
 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);
+    let result = c12_l25_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -284,7 +285,7 @@ fn test_module_1() {
     c19_l32_action_invoke(&mut instance);
     c20_l33_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (func (;0;) (type 0) (param i32) (result i32)
@@ -294,11 +295,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -386,7 +384,7 @@ fn test_module_2() {
     c28_l47_action_invoke(&mut instance);
     c29_l48_action_invoke(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (func (;0;) (type 0) (param i32) (result i32)
@@ -396,11 +394,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -488,7 +483,7 @@ fn test_module_3() {
     c37_l61_action_invoke(&mut instance);
     c38_l62_action_invoke(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i32 i32) (result i32)))
@@ -528,11 +523,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -543,10 +535,7 @@ fn start_module_4(instance: &mut Instance) {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -562,10 +551,7 @@ fn c41_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -581,10 +567,7 @@ fn c43_l90_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -600,10 +583,7 @@ fn c45_l92_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -619,10 +599,7 @@ fn c47_l94_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -638,10 +615,7 @@ fn c49_l96_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -665,7 +639,7 @@ fn test_module_4() {
     c49_l96_action_invoke(&mut instance);
     c50_l97_action_invoke(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32 i32) (result i32)))
       (type (;1;) (func (result i32)))
@@ -935,11 +909,8 @@ fn create_module_5() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
@@ -1038,10 +1009,7 @@ fn c62_l273_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1049,10 +1017,7 @@ fn c63_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -1117,14 +1082,14 @@ fn c71_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c72_l286_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
diff --git a/lib/runtime/tests/spectests/memory_redundancy.rs b/lib/runtime/tests/spectests/memory_redundancy.rs
index 2d2f7458f..dd2ca0c9f 100644
--- a/lib/runtime/tests/spectests/memory_redundancy.rs
+++ b/lib/runtime/tests/spectests/memory_redundancy.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 5
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func (result i32)))
@@ -96,11 +100,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -120,7 +121,7 @@ fn c1_l59_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -136,7 +137,7 @@ fn c3_l61_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
@@ -144,12 +145,7 @@ fn c4_l62_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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)
-        )))
-    );
+    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000049f32)))));
     result.map(|_| ())
 }
 
@@ -157,7 +153,7 @@ fn c5_l63_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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(|_| ())
 }
 
diff --git a/lib/runtime/tests/spectests/memory_trap.rs b/lib/runtime/tests/spectests/memory_trap.rs
index 997bdcbf3..48923f8a3 100644
--- a/lib/runtime/tests/spectests/memory_trap.rs
+++ b/lib/runtime/tests/spectests/memory_trap.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func (param i32 i32)))
@@ -44,11 +48,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -76,14 +77,14 @@ fn c2_l22_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c3_l23_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -91,14 +92,14 @@ fn c3_l23_assert_trap() {
 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);
+    let result = c4_l24_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -106,14 +107,14 @@ fn c4_l24_assert_trap() {
 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);
+    let result = c5_l25_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -121,14 +122,14 @@ fn c5_l25_assert_trap() {
 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);
+    let result = c6_l26_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -136,14 +137,14 @@ fn c6_l26_assert_trap() {
 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);
+    let result = c7_l27_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -151,14 +152,14 @@ fn c7_l27_assert_trap() {
 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);
+    let result = c8_l28_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -166,14 +167,14 @@ fn c8_l28_assert_trap() {
 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);
+    let result = c9_l29_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -181,32 +182,29 @@ fn c9_l29_assert_trap() {
 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);
+    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)],
-    );
-
+    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);
+    let result = c11_l31_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -214,14 +212,14 @@ fn c11_l31_assert_trap() {
 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);
+    let result = c12_l32_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -244,7 +242,7 @@ fn test_module_1() {
     c2_l22_action_invoke(&mut instance);
     c13_l33_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i32) (result i64)))
@@ -360,11 +358,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -375,72 +370,60 @@ fn start_module_2(instance: &mut Instance) {
 // 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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    let result = c18_l114_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -448,14 +431,14 @@ fn c18_l114_assert_trap() {
 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);
+    let result = c19_l115_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -463,14 +446,14 @@ fn c19_l115_assert_trap() {
 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);
+    let result = c20_l116_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -478,14 +461,14 @@ fn c20_l116_assert_trap() {
 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);
+    let result = c21_l117_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -493,158 +476,134 @@ fn c21_l117_assert_trap() {
 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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    let result = c30_l126_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -652,14 +611,14 @@ fn c30_l126_assert_trap() {
 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);
+    let result = c31_l127_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -667,14 +626,14 @@ fn c31_l127_assert_trap() {
 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);
+    let result = c32_l128_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -682,14 +641,14 @@ fn c32_l128_assert_trap() {
 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);
+    let result = c33_l129_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -697,14 +656,14 @@ fn c33_l129_assert_trap() {
 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);
+    let result = c34_l130_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -712,14 +671,14 @@ fn c34_l130_assert_trap() {
 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);
+    let result = c35_l131_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -727,14 +686,14 @@ fn c35_l131_assert_trap() {
 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);
+    let result = c36_l132_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -742,14 +701,14 @@ fn c36_l132_assert_trap() {
 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);
+    let result = c37_l133_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -757,86 +716,74 @@ fn c37_l133_assert_trap() {
 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);
+    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))],
-    );
-
+    let result = instance.call("f32.store", &[Value::I32(65536 as i32), Value::F32((0.0f32))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c39_l135_assert_trap() {
     let mut instance = create_module_2();
-    let result = c39_l135_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f32.store", &[Value::I32(65535 as i32), Value::F32((0.0f32))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c40_l136_assert_trap() {
     let mut instance = create_module_2();
-    let result = c40_l136_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f32.store", &[Value::I32(65534 as i32), Value::F32((0.0f32))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c41_l137_assert_trap() {
     let mut instance = create_module_2();
-    let result = c41_l137_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f32.store", &[Value::I32(65533 as i32), Value::F32((0.0f32))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c42_l138_assert_trap() {
     let mut instance = create_module_2();
-    let result = c42_l138_action_invoke(&mut *instance);
+    let result = c42_l138_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -844,14 +791,14 @@ fn c42_l138_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c43_l139_assert_trap() {
     let mut instance = create_module_2();
-    let result = c43_l139_action_invoke(&mut *instance);
+    let result = c43_l139_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -859,14 +806,14 @@ fn c43_l139_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c44_l140_assert_trap() {
     let mut instance = create_module_2();
-    let result = c44_l140_action_invoke(&mut *instance);
+    let result = c44_l140_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -874,14 +821,14 @@ fn c44_l140_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c45_l141_assert_trap() {
     let mut instance = create_module_2();
-    let result = c45_l141_action_invoke(&mut *instance);
+    let result = c45_l141_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -889,158 +836,134 @@ fn c45_l141_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c46_l142_assert_trap() {
     let mut instance = create_module_2();
-    let result = c46_l142_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f64.store", &[Value::I32(65536 as i32), Value::F64((0.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c47_l143_assert_trap() {
     let mut instance = create_module_2();
-    let result = c47_l143_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f64.store", &[Value::I32(65535 as i32), Value::F64((0.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c48_l144_assert_trap() {
     let mut instance = create_module_2();
-    let result = c48_l144_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f64.store", &[Value::I32(65534 as i32), Value::F64((0.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c49_l145_assert_trap() {
     let mut instance = create_module_2();
-    let result = c49_l145_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f64.store", &[Value::I32(65533 as i32), Value::F64((0.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c50_l146_assert_trap() {
     let mut instance = create_module_2();
-    let result = c50_l146_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f64.store", &[Value::I32(65532 as i32), Value::F64((0.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c51_l147_assert_trap() {
     let mut instance = create_module_2();
-    let result = c51_l147_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f64.store", &[Value::I32(65531 as i32), Value::F64((0.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c52_l148_assert_trap() {
     let mut instance = create_module_2();
-    let result = c52_l148_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f64.store", &[Value::I32(65530 as i32), Value::F64((0.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c53_l149_assert_trap() {
     let mut instance = create_module_2();
-    let result = c53_l149_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("f64.store", &[Value::I32(65529 as i32), Value::F64((0.0f64))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c54_l150_assert_trap() {
     let mut instance = create_module_2();
-    let result = c54_l150_action_invoke(&mut *instance);
+    let result = c54_l150_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1048,14 +971,14 @@ fn c54_l150_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c55_l151_assert_trap() {
     let mut instance = create_module_2();
-    let result = c55_l151_action_invoke(&mut *instance);
+    let result = c55_l151_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1063,14 +986,14 @@ fn c55_l151_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c56_l152_assert_trap() {
     let mut instance = create_module_2();
-    let result = c56_l152_action_invoke(&mut *instance);
+    let result = c56_l152_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1078,14 +1001,14 @@ fn c56_l152_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c57_l153_assert_trap() {
     let mut instance = create_module_2();
-    let result = c57_l153_action_invoke(&mut *instance);
+    let result = c57_l153_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1093,14 +1016,14 @@ fn c57_l153_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c58_l154_assert_trap() {
     let mut instance = create_module_2();
-    let result = c58_l154_action_invoke(&mut *instance);
+    let result = c58_l154_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1108,14 +1031,14 @@ fn c58_l154_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c59_l155_assert_trap() {
     let mut instance = create_module_2();
-    let result = c59_l155_action_invoke(&mut *instance);
+    let result = c59_l155_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1123,14 +1046,14 @@ fn c59_l155_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c60_l156_assert_trap() {
     let mut instance = create_module_2();
-    let result = c60_l156_action_invoke(&mut *instance);
+    let result = c60_l156_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1138,14 +1061,14 @@ fn c60_l156_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c61_l157_assert_trap() {
     let mut instance = create_module_2();
-    let result = c61_l157_action_invoke(&mut *instance);
+    let result = c61_l157_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1153,32 +1076,29 @@ fn c61_l157_assert_trap() {
 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))]);
-
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c62_l158_assert_trap() {
     let mut instance = create_module_2();
-    let result = c62_l158_action_invoke(&mut *instance);
+    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)],
-    );
-
+    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);
+    let result = c63_l159_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1186,104 +1106,89 @@ fn c63_l159_assert_trap() {
 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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    let result = c69_l165_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1291,230 +1196,194 @@ fn c69_l165_assert_trap() {
 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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    let result = c82_l178_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1522,14 +1391,14 @@ fn c82_l178_assert_trap() {
 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);
+    let result = c83_l179_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1537,14 +1406,14 @@ fn c83_l179_assert_trap() {
 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);
+    let result = c84_l180_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1552,14 +1421,14 @@ fn c84_l180_assert_trap() {
 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);
+    let result = c85_l181_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1567,14 +1436,14 @@ fn c85_l181_assert_trap() {
 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);
+    let result = c86_l182_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1582,14 +1451,14 @@ fn c86_l182_assert_trap() {
 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);
+    let result = c87_l183_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1597,14 +1466,14 @@ fn c87_l183_assert_trap() {
 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);
+    let result = c88_l184_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1612,14 +1481,14 @@ fn c88_l184_assert_trap() {
 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);
+    let result = c89_l185_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1627,14 +1496,14 @@ fn c89_l185_assert_trap() {
 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);
+    let result = c90_l186_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1642,14 +1511,14 @@ fn c90_l186_assert_trap() {
 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);
+    let result = c91_l187_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1657,14 +1526,14 @@ fn c91_l187_assert_trap() {
 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);
+    let result = c92_l188_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1672,14 +1541,14 @@ fn c92_l188_assert_trap() {
 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);
+    let result = c93_l189_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1687,14 +1556,14 @@ fn c93_l189_assert_trap() {
 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);
+    let result = c94_l190_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1702,14 +1571,14 @@ fn c94_l190_assert_trap() {
 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);
+    let result = c95_l191_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1717,14 +1586,14 @@ fn c95_l191_assert_trap() {
 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);
+    let result = c96_l192_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1732,14 +1601,14 @@ fn c96_l192_assert_trap() {
 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);
+    let result = c97_l193_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1747,14 +1616,14 @@ fn c97_l193_assert_trap() {
 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);
+    let result = c98_l194_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1762,14 +1631,14 @@ fn c98_l194_assert_trap() {
 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);
+    let result = c99_l195_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1777,14 +1646,14 @@ fn c99_l195_assert_trap() {
 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);
+    let result = c100_l196_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1792,14 +1661,14 @@ fn c100_l196_assert_trap() {
 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);
+    let result = c101_l197_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1807,14 +1676,14 @@ fn c101_l197_assert_trap() {
 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);
+    let result = c102_l198_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1822,14 +1691,14 @@ fn c102_l198_assert_trap() {
 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);
+    let result = c103_l199_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1837,14 +1706,14 @@ fn c103_l199_assert_trap() {
 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);
+    let result = c104_l200_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1852,14 +1721,14 @@ fn c104_l200_assert_trap() {
 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);
+    let result = c105_l201_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1867,14 +1736,14 @@ fn c105_l201_assert_trap() {
 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);
+    let result = c106_l202_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1882,14 +1751,14 @@ fn c106_l202_assert_trap() {
 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);
+    let result = c107_l203_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1897,14 +1766,14 @@ fn c107_l203_assert_trap() {
 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);
+    let result = c108_l204_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1912,14 +1781,14 @@ fn c108_l204_assert_trap() {
 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);
+    let result = c109_l205_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1927,14 +1796,14 @@ fn c109_l205_assert_trap() {
 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);
+    let result = c110_l206_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1942,14 +1811,14 @@ fn c110_l206_assert_trap() {
 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);
+    let result = c111_l207_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1957,14 +1826,14 @@ fn c111_l207_assert_trap() {
 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);
+    let result = c112_l208_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1972,14 +1841,14 @@ fn c112_l208_assert_trap() {
 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);
+    let result = c113_l209_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -1987,14 +1856,14 @@ fn c113_l209_assert_trap() {
 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);
+    let result = c114_l210_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2002,14 +1871,14 @@ fn c114_l210_assert_trap() {
 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);
+    let result = c115_l211_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2017,14 +1886,14 @@ fn c115_l211_assert_trap() {
 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);
+    let result = c116_l212_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2032,14 +1901,14 @@ fn c116_l212_assert_trap() {
 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);
+    let result = c117_l213_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2047,14 +1916,14 @@ fn c117_l213_assert_trap() {
 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);
+    let result = c118_l214_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2062,14 +1931,14 @@ fn c118_l214_assert_trap() {
 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);
+    let result = c119_l215_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2077,14 +1946,14 @@ fn c119_l215_assert_trap() {
 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);
+    let result = c120_l216_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2092,14 +1961,14 @@ fn c120_l216_assert_trap() {
 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);
+    let result = c121_l217_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2107,14 +1976,14 @@ fn c121_l217_assert_trap() {
 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);
+    let result = c122_l218_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2122,14 +1991,14 @@ fn c122_l218_assert_trap() {
 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);
+    let result = c123_l219_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2137,14 +2006,14 @@ fn c123_l219_assert_trap() {
 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);
+    let result = c124_l220_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2152,14 +2021,14 @@ fn c124_l220_assert_trap() {
 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);
+    let result = c125_l221_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2167,14 +2036,14 @@ fn c125_l221_assert_trap() {
 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);
+    let result = c126_l222_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2182,14 +2051,14 @@ fn c126_l222_assert_trap() {
 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);
+    let result = c127_l223_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2197,14 +2066,14 @@ fn c127_l223_assert_trap() {
 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);
+    let result = c128_l224_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2212,14 +2081,14 @@ fn c128_l224_assert_trap() {
 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);
+    let result = c129_l225_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2227,14 +2096,14 @@ fn c129_l225_assert_trap() {
 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);
+    let result = c130_l226_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2242,14 +2111,14 @@ fn c130_l226_assert_trap() {
 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);
+    let result = c131_l227_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2257,14 +2126,14 @@ fn c131_l227_assert_trap() {
 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);
+    let result = c132_l228_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2272,14 +2141,14 @@ fn c132_l228_assert_trap() {
 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);
+    let result = c133_l229_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2287,14 +2156,14 @@ fn c133_l229_assert_trap() {
 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);
+    let result = c134_l230_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2302,14 +2171,14 @@ fn c134_l230_assert_trap() {
 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);
+    let result = c135_l231_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2317,14 +2186,14 @@ fn c135_l231_assert_trap() {
 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);
+    let result = c136_l232_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2332,14 +2201,14 @@ fn c136_l232_assert_trap() {
 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);
+    let result = c137_l233_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2347,14 +2216,14 @@ fn c137_l233_assert_trap() {
 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);
+    let result = c138_l234_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2362,14 +2231,14 @@ fn c138_l234_assert_trap() {
 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);
+    let result = c139_l235_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2377,14 +2246,14 @@ fn c139_l235_assert_trap() {
 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);
+    let result = c140_l236_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2392,14 +2261,14 @@ fn c140_l236_assert_trap() {
 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);
+    let result = c141_l237_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2407,14 +2276,14 @@ fn c141_l237_assert_trap() {
 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);
+    let result = c142_l238_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2422,14 +2291,14 @@ fn c142_l238_assert_trap() {
 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);
+    let result = c143_l239_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2437,14 +2306,14 @@ fn c143_l239_assert_trap() {
 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);
+    let result = c144_l240_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2452,14 +2321,14 @@ fn c144_l240_assert_trap() {
 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);
+    let result = c145_l241_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2467,14 +2336,14 @@ fn c145_l241_assert_trap() {
 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);
+    let result = c146_l242_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2482,14 +2351,14 @@ fn c146_l242_assert_trap() {
 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);
+    let result = c147_l243_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2497,14 +2366,14 @@ fn c147_l243_assert_trap() {
 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);
+    let result = c148_l244_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2512,14 +2381,14 @@ fn c148_l244_assert_trap() {
 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);
+    let result = c149_l245_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2527,14 +2396,14 @@ fn c149_l245_assert_trap() {
 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);
+    let result = c150_l246_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2542,14 +2411,14 @@ fn c150_l246_assert_trap() {
 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);
+    let result = c151_l247_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2557,14 +2426,14 @@ fn c151_l247_assert_trap() {
 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);
+    let result = c152_l248_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2572,14 +2441,14 @@ fn c152_l248_assert_trap() {
 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);
+    let result = c153_l249_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2587,14 +2456,14 @@ fn c153_l249_assert_trap() {
 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);
+    let result = c154_l250_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2602,14 +2471,14 @@ fn c154_l250_assert_trap() {
 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);
+    let result = c155_l251_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2617,14 +2486,14 @@ fn c155_l251_assert_trap() {
 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);
+    let result = c156_l252_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2632,14 +2501,14 @@ fn c156_l252_assert_trap() {
 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);
+    let result = c157_l253_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2647,14 +2516,14 @@ fn c157_l253_assert_trap() {
 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);
+    let result = c158_l254_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2662,14 +2531,14 @@ fn c158_l254_assert_trap() {
 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);
+    let result = c159_l255_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2677,14 +2546,14 @@ fn c159_l255_assert_trap() {
 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);
+    let result = c160_l256_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2692,14 +2561,14 @@ fn c160_l256_assert_trap() {
 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);
+    let result = c161_l257_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2707,14 +2576,14 @@ fn c161_l257_assert_trap() {
 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);
+    let result = c162_l258_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2722,14 +2591,14 @@ fn c162_l258_assert_trap() {
 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);
+    let result = c163_l259_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2737,14 +2606,14 @@ fn c163_l259_assert_trap() {
 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);
+    let result = c164_l260_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2752,14 +2621,14 @@ fn c164_l260_assert_trap() {
 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);
+    let result = c165_l261_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2767,14 +2636,14 @@ fn c165_l261_assert_trap() {
 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);
+    let result = c166_l262_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2782,14 +2651,14 @@ fn c166_l262_assert_trap() {
 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);
+    let result = c167_l263_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2797,14 +2666,14 @@ fn c167_l263_assert_trap() {
 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);
+    let result = c168_l264_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2812,14 +2681,14 @@ fn c168_l264_assert_trap() {
 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);
+    let result = c169_l265_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -2827,14 +2696,14 @@ fn c169_l265_assert_trap() {
 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);
+    let result = c170_l266_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
diff --git a/lib/runtime/tests/spectests/nop.rs b/lib/runtime/tests/spectests/nop.rs
index 61c00bf80..4f7df731c 100644
--- a/lib/runtime/tests/spectests/nop.rs
+++ b/lib/runtime/tests/spectests/nop.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32) (result i32)))
       (type (;1;) (func))
@@ -634,11 +638,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -969,14 +970,7 @@ fn c40_l354_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -984,14 +978,7 @@ fn c41_l356_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -999,14 +986,7 @@ fn c42_l357_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1014,14 +994,7 @@ fn c43_l358_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1029,14 +1002,7 @@ fn c44_l359_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -1316,10 +1282,7 @@ fn c79_l404_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("as-store-first", &[Value::I32(0 as i32), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(None));
     result.map(|_| ())
 }
@@ -1327,10 +1290,7 @@ fn c80_l406_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("as-store-mid", &[Value::I32(0 as i32), Value::I32(2 as i32)]);
     assert_eq!(result, Ok(None));
     result.map(|_| ())
 }
@@ -1338,10 +1298,7 @@ fn c81_l407_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("as-store-last", &[Value::I32(0 as i32), Value::I32(3 as i32)]);
     assert_eq!(result, Ok(None));
     result.map(|_| ())
 }
@@ -1349,10 +1306,7 @@ fn c82_l408_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    let result = instance.call("as-store-everywhere", &[Value::I32(0 as i32), Value::I32(4 as i32)]);
     assert_eq!(result, Ok(None));
     result.map(|_| ())
 }
@@ -1360,9 +1314,7 @@ fn c83_l409_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -1370,9 +1322,7 @@ fn c84_l412_assert_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 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");
 }
@@ -1380,9 +1330,7 @@ fn c85_l416_assert_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 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");
 }
@@ -1390,9 +1338,7 @@ fn c86_l420_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/return_.rs b/lib/runtime/tests/spectests/return_.rs
index 9924494bc..76d96cbd8 100644
--- a/lib/runtime/tests/spectests/return_.rs
+++ b/lib/runtime/tests/spectests/return_.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32 i32) (result i32)))
       (type (;1;) (func))
@@ -414,11 +418,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -701,10 +702,7 @@ fn c34_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -712,10 +710,7 @@ fn c35_l262_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -723,10 +718,7 @@ fn c36_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -734,10 +726,7 @@ fn c37_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)],
-    );
+    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(|_| ())
 }
@@ -929,9 +918,7 @@ fn c61_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -939,9 +926,7 @@ fn c62_l302_assert_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 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");
 }
@@ -949,10 +934,7 @@ fn c63_l306_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/select.rs b/lib/runtime/tests/spectests/select.rs
index 9b230e464..5940658fa 100644
--- a/lib/runtime/tests/spectests/select.rs
+++ b/lib/runtime/tests/spectests/select.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32 i32) (result i32)))
       (type (;1;) (func (param i64 i64 i32) (result i64)))
@@ -77,11 +81,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -92,14 +93,7 @@ fn start_module_1(instance: &mut Instance) {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -107,14 +101,7 @@ fn c1_l31_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -122,14 +109,7 @@ fn c2_l32_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((2.0f32)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32((1.0f32)), Value::F32((2.0f32)), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -137,14 +117,7 @@ fn c3_l33_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((2.0f64)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64((1.0f64)), Value::F64((2.0f64)), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -152,14 +125,7 @@ fn c4_l34_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -167,14 +133,7 @@ fn c5_l36_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -182,14 +141,7 @@ fn c6_l37_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -197,14 +149,7 @@ fn c7_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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),
-        ],
-    );
+    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(|_| ())
 }
@@ -212,62 +157,35 @@ fn c8_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32)), 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);
-    }
+                                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)),
-            Value::F32((1.0f32)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2139226884)), Value::F32((1.0f32)), 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);
-    }
+                                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)),
-            Value::F32((1.0f32)),
-            Value::I32(0 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32)), Value::I32(0 as i32)]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -275,14 +193,7 @@ fn c11_l43_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32((1.0f32)),
-            Value::I32(0 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2139226884)), Value::F32((1.0f32)), Value::I32(0 as i32)]);
     assert_eq!(result, Ok(Some(Value::F32((1.0f32)))));
     result.map(|_| ())
 }
@@ -290,14 +201,7 @@ fn c12_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344)), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(Some(Value::F32((2.0f32)))));
     result.map(|_| ())
 }
@@ -305,14 +209,7 @@ fn c13_l45_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2139226884)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2139226884)), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(Some(Value::F32((2.0f32)))));
     result.map(|_| ())
 }
@@ -320,110 +217,63 @@ fn c14_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F32(f32::from_bits(2143289344)),
-            Value::I32(0 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344)), 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);
-    }
+                                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)),
-            Value::F32(f32::from_bits(2139226884)),
-            Value::I32(0 as i32),
-        ],
-    );
+    let result = instance.call("select_f32", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2139226884)), 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);
-    }
+                                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)),
-            Value::F64((1.0f64)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64)), 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);
-    }
+                                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)),
-            Value::F64((1.0f64)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9218868437227537156)), Value::F64((1.0f64)), 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);
-    }
+                                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)),
-            Value::F64((1.0f64)),
-            Value::I32(0 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64)), Value::I32(0 as i32)]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -431,14 +281,7 @@ fn c19_l52_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((1.0f64)),
-            Value::I32(0 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9218868437227537156)), Value::F64((1.0f64)), Value::I32(0 as i32)]);
     assert_eq!(result, Ok(Some(Value::F64((1.0f64)))));
     result.map(|_| ())
 }
@@ -446,14 +289,7 @@ fn c20_l53_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560)), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(Some(Value::F64((2.0f64)))));
     result.map(|_| ())
 }
@@ -461,14 +297,7 @@ fn c21_l54_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9218868437227537156)),
-            Value::I32(1 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9218868437227537156)), Value::I32(1 as i32)]);
     assert_eq!(result, Ok(Some(Value::F64((2.0f64)))));
     result.map(|_| ())
 }
@@ -476,48 +305,28 @@ fn c22_l55_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64(f64::from_bits(9221120237041090560)),
-            Value::I32(0 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560)), 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);
-    }
+                                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)),
-            Value::F64(f64::from_bits(9218868437227537156)),
-            Value::I32(0 as i32),
-        ],
-    );
+    let result = instance.call("select_f64", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9218868437227537156)), 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);
-    }
+                                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(|_| ())
 }
 
@@ -525,14 +334,14 @@ fn c24_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c25_l59_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -540,14 +349,14 @@ fn c25_l59_assert_trap() {
 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);
+    let result = c26_l60_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -555,14 +364,14 @@ fn c26_l60_assert_trap() {
 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);
+    let result = c27_l61_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -570,24 +379,21 @@ fn c27_l61_assert_trap() {
 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);
+    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 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");
 }
diff --git a/lib/runtime/tests/spectests/set_local.rs b/lib/runtime/tests/spectests/set_local.rs
index baf0ded06..79ace6b6a 100644
--- a/lib/runtime/tests/spectests/set_local.rs
+++ b/lib/runtime/tests/spectests/set_local.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func (param i32)))
@@ -123,11 +127,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -202,16 +203,7 @@ fn c8_l76_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((3.3f64)),
-            Value::I32(4 as i32),
-            Value::I32(5 as i32),
-        ],
-    );
+    let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]);
     assert_eq!(result, Ok(None));
     result.map(|_| ())
 }
@@ -219,16 +211,7 @@ fn c9_l79_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((3.3f64)),
-            Value::I32(4 as i32),
-            Value::I32(5 as i32),
-        ],
-    );
+    let result = instance.call("write", &[Value::I64(1 as i64), Value::F32((2.0f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]);
     assert_eq!(result, Ok(Some(Value::I64(56 as i64))));
     result.map(|_| ())
 }
@@ -236,10 +219,7 @@ fn c10_l85_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -247,10 +227,7 @@ fn c11_l95_assert_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 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");
 }
@@ -258,10 +235,7 @@ fn c12_l101_assert_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 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");
 }
@@ -269,10 +243,7 @@ fn c13_l107_assert_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 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");
 }
@@ -280,10 +251,7 @@ fn c14_l114_assert_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 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");
 }
@@ -291,10 +259,7 @@ fn c15_l118_assert_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 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");
 }
@@ -302,10 +267,7 @@ fn c16_l122_assert_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 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");
 }
@@ -313,10 +275,7 @@ fn c17_l126_assert_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 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");
 }
@@ -324,10 +283,7 @@ fn c18_l134_assert_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 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");
 }
@@ -335,10 +291,7 @@ fn c19_l138_assert_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 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");
 }
@@ -346,10 +299,7 @@ fn c20_l142_assert_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 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");
 }
@@ -357,10 +307,7 @@ fn c21_l147_assert_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 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");
 }
@@ -368,10 +315,7 @@ fn c22_l151_assert_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 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");
 }
@@ -379,10 +323,7 @@ fn c23_l155_assert_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 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");
 }
@@ -390,10 +331,7 @@ fn c24_l159_assert_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 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");
 }
@@ -401,10 +339,7 @@ fn c25_l167_assert_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 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");
 }
@@ -412,10 +347,7 @@ fn c26_l171_assert_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 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");
 }
@@ -423,10 +355,7 @@ fn c27_l176_assert_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 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");
 }
@@ -434,10 +363,7 @@ fn c28_l180_assert_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 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");
 }
@@ -445,10 +371,7 @@ fn c29_l185_assert_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 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");
 }
@@ -456,10 +379,7 @@ fn c30_l189_assert_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 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");
 }
@@ -467,10 +387,7 @@ fn c31_l194_assert_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 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");
 }
@@ -478,10 +395,7 @@ fn c32_l198_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/stack.rs b/lib/runtime/tests/spectests/stack.rs
index 0c530803f..884803c95 100644
--- a/lib/runtime/tests/spectests/stack.rs
+++ b/lib/runtime/tests/spectests/stack.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i64) (result i64)))
       (func (;0;) (type 0) (param i64) (result i64)
@@ -160,11 +164,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -207,7 +208,7 @@ fn test_module_1() {
     c2_l131_action_invoke(&mut instance);
     c3_l132_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func (param i32)))
@@ -434,11 +435,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
diff --git a/lib/runtime/tests/spectests/start.rs b/lib/runtime/tests/spectests/start.rs
index e105e00f6..82378b9cf 100644
--- a/lib/runtime/tests/spectests/start.rs
+++ b/lib/runtime/tests/spectests/start.rs
@@ -5,21 +5,23 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, 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 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");
 }
@@ -27,10 +29,7 @@ fn c0_l2_assert_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 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");
 }
@@ -38,16 +37,13 @@ fn c1_l7_assert_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 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<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func (result i32)))
@@ -73,11 +69,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -97,7 +90,7 @@ fn c4_l45_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c5_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c5_l46_action_invoke");
     let result = instance.call("inc", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -113,7 +106,7 @@ fn c6_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c7_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c7_l48_action_invoke");
     let result = instance.call("inc", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -138,7 +131,7 @@ fn test_module_1() {
     c7_l48_action_invoke(&mut instance);
     c8_l49_action_invoke(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func (result i32)))
@@ -164,11 +157,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -188,7 +178,7 @@ fn c10_l74_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c11_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c11_l75_action_invoke");
     let result = instance.call("inc", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -204,7 +194,7 @@ fn c12_l76_action_invoke(instance: &mut Instance) -> Result<(), String> {
 fn c13_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
     println!("Executing function {}", "c13_l77_action_invoke");
     let result = instance.call("inc", &[]);
-
+    
     result.map(|_| ())
 }
 
@@ -229,7 +219,7 @@ fn test_module_2() {
     c13_l77_action_invoke(&mut instance);
     c14_l78_action_invoke(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32)))
       (type (;1;) (func))
@@ -240,11 +230,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -260,7 +247,7 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32)))
       (type (;1;) (func))
@@ -271,11 +258,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -291,18 +275,15 @@ fn test_module_4() {
     // We group the calls together
     start_module_4(&mut instance);
 }
-fn create_module_5() -> Box<Instance> {
+fn create_module_5() -> Instance {
     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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_5(instance: &mut Instance) {
diff --git a/lib/runtime/tests/spectests/store_retval.rs b/lib/runtime/tests/spectests/store_retval.rs
index 58845767e..9991fcc01 100644
--- a/lib/runtime/tests/spectests/store_retval.rs
+++ b/lib/runtime/tests/spectests/store_retval.rs
@@ -5,22 +5,23 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, 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 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");
 }
@@ -28,10 +29,7 @@ fn c0_l2_assert_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 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");
 }
@@ -39,10 +37,7 @@ fn c1_l6_assert_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 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");
 }
@@ -50,10 +45,7 @@ fn c2_l10_assert_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 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");
 }
@@ -61,10 +53,7 @@ fn c3_l14_assert_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 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");
 }
@@ -72,10 +61,7 @@ fn c4_l19_assert_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 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");
 }
@@ -83,10 +69,7 @@ fn c5_l23_assert_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 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");
 }
@@ -94,10 +77,7 @@ fn c6_l27_assert_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 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");
 }
@@ -105,10 +85,7 @@ fn c7_l31_assert_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 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");
 }
@@ -116,10 +93,7 @@ fn c8_l36_assert_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 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");
 }
@@ -127,10 +101,7 @@ fn c9_l40_assert_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 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");
 }
@@ -138,10 +109,7 @@ fn c10_l44_assert_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 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");
 }
@@ -149,10 +117,7 @@ fn c11_l48_assert_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 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
index a09a6a89f..008094ba2 100644
--- a/lib/runtime/tests/spectests/switch.rs
+++ b/lib/runtime/tests/spectests/switch.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 1
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32) (result i32)))
       (type (;1;) (func (param i64) (result i64)))
@@ -139,11 +143,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -362,10 +363,7 @@ fn c26_l148_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
diff --git a/lib/runtime/tests/spectests/tee_local.rs b/lib/runtime/tests/spectests/tee_local.rs
index 585ce1bc8..555b6ab13 100644
--- a/lib/runtime/tests/spectests/tee_local.rs
+++ b/lib/runtime/tests/spectests/tee_local.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (result i32)))
       (type (;1;) (func (result i64)))
@@ -187,11 +191,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -266,16 +267,7 @@ fn c8_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((3.3f64)),
-            Value::I32(4 as i32),
-            Value::I32(5 as i32),
-        ],
-    );
+    let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]);
     assert_eq!(result, Ok(None));
     result.map(|_| ())
 }
@@ -283,16 +275,7 @@ fn c9_l109_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((3.3f64)),
-            Value::I32(4 as i32),
-            Value::I32(5 as i32),
-        ],
-    );
+    let result = instance.call("write", &[Value::I64(1 as i64), Value::F32((2.0f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]);
     assert_eq!(result, Ok(Some(Value::I64(56 as i64))));
     result.map(|_| ())
 }
@@ -300,16 +283,7 @@ fn c10_l115_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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)),
-            Value::F64((-3.3f64)),
-            Value::I32(-4 as i32),
-            Value::I32(-5 as i32),
-        ],
-    );
+    let result = instance.call("result", &[Value::I64(-1 as i64), Value::F32((-2.0f32)), Value::F64((-3.3f64)), Value::I32(-4 as i32), Value::I32(-5 as i32)]);
     assert_eq!(result, Ok(Some(Value::F64((34.8f64)))));
     result.map(|_| ())
 }
@@ -317,10 +291,7 @@ fn c11_l122_action_invoke(instance: &mut Instance) -> Result<(), String> {
 // 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 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");
 }
@@ -328,10 +299,7 @@ fn c12_l132_assert_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 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");
 }
@@ -339,10 +307,7 @@ fn c13_l136_assert_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 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");
 }
@@ -350,10 +315,7 @@ fn c14_l140_assert_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 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");
 }
@@ -361,10 +323,7 @@ fn c15_l145_assert_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 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");
 }
@@ -372,10 +331,7 @@ fn c16_l149_assert_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 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");
 }
@@ -383,10 +339,7 @@ fn c17_l153_assert_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 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");
 }
@@ -394,10 +347,7 @@ fn c18_l157_assert_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 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");
 }
@@ -405,10 +355,7 @@ fn c19_l165_assert_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 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");
 }
@@ -416,10 +363,7 @@ fn c20_l169_assert_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 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");
 }
@@ -427,10 +371,7 @@ fn c21_l173_assert_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 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");
 }
@@ -438,10 +379,7 @@ fn c22_l178_assert_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 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");
 }
@@ -449,10 +387,7 @@ fn c23_l182_assert_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 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");
 }
@@ -460,10 +395,7 @@ fn c24_l186_assert_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 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");
 }
@@ -471,10 +403,7 @@ fn c25_l190_assert_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 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");
 }
@@ -482,10 +411,7 @@ fn c26_l198_assert_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 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");
 }
@@ -493,10 +419,7 @@ fn c27_l202_assert_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 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");
 }
@@ -504,10 +427,7 @@ fn c28_l207_assert_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 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");
 }
@@ -515,10 +435,7 @@ fn c29_l211_assert_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 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");
 }
@@ -526,10 +443,7 @@ fn c30_l216_assert_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 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");
 }
@@ -537,10 +451,7 @@ fn c31_l220_assert_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 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");
 }
@@ -548,10 +459,7 @@ fn c32_l225_assert_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 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");
 }
@@ -559,10 +467,7 @@ fn c33_l229_assert_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 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");
 }
diff --git a/lib/runtime/tests/spectests/token.rs b/lib/runtime/tests/spectests/token.rs
index b8ba7435f..e4d5588ef 100644
--- a/lib/runtime/tests/spectests/token.rs
+++ b/lib/runtime/tests/spectests/token.rs
@@ -5,38 +5,31 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, 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 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"
-    );
+    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 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"
-    );
+    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
index 64519a573..45c5ae550 100644
--- a/lib/runtime/tests/spectests/traps.rs
+++ b/lib/runtime/tests/spectests/traps.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 5
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32)))
       (type (;1;) (func (param i64 i64)))
@@ -45,11 +49,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -60,111 +61,90 @@ fn start_module_1(instance: &mut Instance) {
 // 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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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),
-        ],
-    );
-
+    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);
+    let result = c6_l21_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -176,7 +156,7 @@ fn test_module_1() {
     // We group the calls together
     start_module_1(&mut instance);
 }
-fn create_module_2() -> Box<Instance> {
+fn create_module_2() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32 i32)))
       (type (;1;) (func (param i64 i64)))
@@ -206,11 +186,8 @@ fn create_module_2() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_2(instance: &mut Instance) {
@@ -221,72 +198,60 @@ fn start_module_2(instance: &mut Instance) {
 // 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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    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)],
-    );
-
+    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);
+    let result = c11_l37_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -298,7 +263,7 @@ fn test_module_2() {
     // We group the calls together
     start_module_2(&mut instance);
 }
-fn create_module_3() -> Box<Instance> {
+fn create_module_3() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param f32)))
       (type (;1;) (func (param f64)))
@@ -344,11 +309,8 @@ fn create_module_3() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_3(instance: &mut Instance) {
@@ -359,144 +321,120 @@ fn start_module_3(instance: &mut Instance) {
 // 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))],
-    );
-
+    let result = instance.call("no_dce.i32.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c13_l50_assert_trap() {
     let mut instance = create_module_3();
-    let result = c13_l50_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("no_dce.i32.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c14_l51_assert_trap() {
     let mut instance = create_module_3();
-    let result = c14_l51_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("no_dce.i32.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c15_l52_assert_trap() {
     let mut instance = create_module_3();
-    let result = c15_l52_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("no_dce.i32.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c16_l53_assert_trap() {
     let mut instance = create_module_3();
-    let result = c16_l53_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("no_dce.i64.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c17_l54_assert_trap() {
     let mut instance = create_module_3();
-    let result = c17_l54_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("no_dce.i64.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c18_l55_assert_trap() {
     let mut instance = create_module_3();
-    let result = c18_l55_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("no_dce.i64.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c19_l56_assert_trap() {
     let mut instance = create_module_3();
-    let result = c19_l56_action_invoke(&mut *instance);
+    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))],
-    );
-
+    let result = instance.call("no_dce.i64.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560))]);
+    
     result.map(|_| ())
 }
 
 #[test]
 fn c20_l57_assert_trap() {
     let mut instance = create_module_3();
-    let result = c20_l57_action_invoke(&mut *instance);
+    let result = c20_l57_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -508,7 +446,7 @@ fn test_module_3() {
     // We group the calls together
     start_module_3(&mut instance);
 }
-fn create_module_4() -> Box<Instance> {
+fn create_module_4() -> Instance {
     let module_str = "(module
       (type (;0;) (func (param i32)))
       (func (;0;) (type 0) (param i32)
@@ -584,11 +522,8 @@ fn create_module_4() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_4(instance: &mut Instance) {
@@ -600,14 +535,14 @@ fn start_module_4(instance: &mut Instance) {
 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);
+    let result = c22_l78_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -615,14 +550,14 @@ fn c22_l78_assert_trap() {
 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);
+    let result = c23_l79_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -630,14 +565,14 @@ fn c23_l79_assert_trap() {
 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);
+    let result = c24_l80_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -645,14 +580,14 @@ fn c24_l80_assert_trap() {
 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);
+    let result = c25_l81_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -660,14 +595,14 @@ fn c25_l81_assert_trap() {
 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);
+    let result = c26_l82_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -675,14 +610,14 @@ fn c26_l82_assert_trap() {
 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);
+    let result = c27_l83_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -690,14 +625,14 @@ fn c27_l83_assert_trap() {
 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);
+    let result = c28_l84_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -705,14 +640,14 @@ fn c28_l84_assert_trap() {
 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);
+    let result = c29_l85_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -720,14 +655,14 @@ fn c29_l85_assert_trap() {
 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);
+    let result = c30_l86_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -735,14 +670,14 @@ fn c30_l86_assert_trap() {
 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);
+    let result = c31_l87_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -750,14 +685,14 @@ fn c31_l87_assert_trap() {
 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);
+    let result = c32_l88_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -765,14 +700,14 @@ fn c32_l88_assert_trap() {
 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);
+    let result = c33_l89_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -780,14 +715,14 @@ fn c33_l89_assert_trap() {
 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);
+    let result = c34_l90_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -795,14 +730,14 @@ fn c34_l90_assert_trap() {
 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);
+    let result = c35_l91_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
diff --git a/lib/runtime/tests/spectests/typecheck.rs b/lib/runtime/tests/spectests/typecheck.rs
index c139aef85..2e729ad8a 100644
--- a/lib/runtime/tests/spectests/typecheck.rs
+++ b/lib/runtime/tests/spectests/typecheck.rs
@@ -5,21 +5,23 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, 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 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");
 }
@@ -27,10 +29,7 @@ fn c0_l4_assert_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 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");
 }
@@ -38,10 +37,7 @@ fn c1_l10_assert_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 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");
 }
@@ -49,10 +45,7 @@ fn c2_l17_assert_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 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");
 }
@@ -60,10 +53,7 @@ fn c3_l24_assert_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 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");
 }
@@ -71,9 +61,7 @@ fn c4_l31_assert_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 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");
 }
@@ -81,10 +69,7 @@ fn c5_l39_assert_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 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");
 }
@@ -92,10 +77,7 @@ fn c6_l45_assert_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 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");
 }
@@ -103,10 +85,7 @@ fn c7_l51_assert_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 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");
 }
@@ -114,10 +93,7 @@ fn c8_l58_assert_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 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");
 }
@@ -125,10 +101,7 @@ fn c9_l65_assert_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 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");
 }
@@ -136,10 +109,7 @@ fn c10_l72_assert_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 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");
 }
@@ -147,10 +117,7 @@ fn c11_l79_assert_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 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");
 }
@@ -158,10 +125,7 @@ fn c12_l86_assert_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 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");
 }
@@ -169,10 +133,7 @@ fn c13_l93_assert_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 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");
 }
@@ -180,9 +141,7 @@ fn c14_l101_assert_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 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");
 }
@@ -190,10 +149,7 @@ fn c15_l110_assert_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 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");
 }
@@ -201,10 +157,7 @@ fn c16_l116_assert_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 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");
 }
@@ -212,10 +165,7 @@ fn c17_l123_assert_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 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");
 }
@@ -223,10 +173,7 @@ fn c18_l130_assert_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 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");
 }
@@ -234,10 +181,7 @@ fn c19_l137_assert_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 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");
 }
@@ -245,10 +189,7 @@ fn c20_l146_assert_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 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");
 }
@@ -256,10 +197,7 @@ fn c21_l153_assert_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 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");
 }
@@ -267,10 +205,7 @@ fn c22_l161_assert_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 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");
 }
@@ -278,9 +213,7 @@ fn c23_l171_assert_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 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");
 }
@@ -288,10 +221,7 @@ fn c24_l182_assert_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 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");
 }
@@ -299,10 +229,7 @@ fn c25_l188_assert_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 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");
 }
@@ -310,10 +237,7 @@ fn c26_l195_assert_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 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");
 }
@@ -321,10 +245,7 @@ fn c27_l202_assert_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 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");
 }
@@ -332,10 +253,7 @@ fn c28_l209_assert_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 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");
 }
@@ -343,10 +261,7 @@ fn c29_l219_assert_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 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");
 }
@@ -354,10 +269,7 @@ fn c30_l222_assert_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 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");
 }
@@ -365,10 +277,7 @@ fn c31_l226_assert_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 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");
 }
@@ -376,10 +285,7 @@ fn c32_l230_assert_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 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");
 }
@@ -387,10 +293,7 @@ fn c33_l232_assert_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 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");
 }
@@ -398,10 +301,7 @@ fn c34_l242_assert_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 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");
 }
@@ -409,10 +309,7 @@ fn c35_l250_assert_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 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");
 }
@@ -420,10 +317,7 @@ fn c36_l253_assert_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 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");
 }
@@ -431,10 +325,7 @@ fn c37_l256_assert_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 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");
 }
@@ -442,10 +333,7 @@ fn c38_l257_assert_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 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");
 }
@@ -453,10 +341,7 @@ fn c39_l258_assert_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 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");
 }
@@ -464,10 +349,7 @@ fn c40_l259_assert_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 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");
 }
@@ -475,10 +357,7 @@ fn c41_l260_assert_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 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");
 }
@@ -486,10 +365,7 @@ fn c42_l261_assert_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 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");
 }
@@ -497,10 +373,7 @@ fn c43_l262_assert_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 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");
 }
@@ -508,10 +381,7 @@ fn c44_l263_assert_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 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");
 }
@@ -519,10 +389,7 @@ fn c45_l264_assert_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 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");
 }
@@ -530,10 +397,7 @@ fn c46_l265_assert_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 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");
 }
@@ -541,10 +405,7 @@ fn c47_l266_assert_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 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");
 }
@@ -552,10 +413,7 @@ fn c48_l267_assert_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 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");
 }
@@ -563,10 +421,7 @@ fn c49_l268_assert_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 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");
 }
@@ -574,10 +429,7 @@ fn c50_l269_assert_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 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");
 }
@@ -585,10 +437,7 @@ fn c51_l272_assert_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 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");
 }
@@ -596,10 +445,7 @@ fn c52_l273_assert_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 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");
 }
@@ -607,10 +453,7 @@ fn c53_l274_assert_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 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");
 }
@@ -618,10 +461,7 @@ fn c54_l275_assert_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 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");
 }
@@ -629,10 +469,7 @@ fn c55_l276_assert_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 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");
 }
@@ -640,10 +477,7 @@ fn c56_l277_assert_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 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");
 }
@@ -651,10 +485,7 @@ fn c57_l278_assert_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 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");
 }
@@ -662,10 +493,7 @@ fn c58_l279_assert_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 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");
 }
@@ -673,10 +501,7 @@ fn c59_l280_assert_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 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");
 }
@@ -684,10 +509,7 @@ fn c60_l283_assert_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 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");
 }
@@ -695,10 +517,7 @@ fn c61_l284_assert_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 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");
 }
@@ -706,10 +525,7 @@ fn c62_l285_assert_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 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");
 }
@@ -717,10 +533,7 @@ fn c63_l286_assert_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 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");
 }
@@ -728,10 +541,7 @@ fn c64_l287_assert_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 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");
 }
@@ -739,10 +549,7 @@ fn c65_l288_assert_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 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");
 }
@@ -750,10 +557,7 @@ fn c66_l289_assert_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 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");
 }
@@ -761,10 +565,7 @@ fn c67_l290_assert_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 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");
 }
@@ -772,10 +573,7 @@ fn c68_l291_assert_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 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");
 }
@@ -783,10 +581,7 @@ fn c69_l294_assert_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 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");
 }
@@ -794,10 +589,7 @@ fn c70_l295_assert_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 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");
 }
@@ -805,10 +597,7 @@ fn c71_l296_assert_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 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");
 }
@@ -816,10 +605,7 @@ fn c72_l297_assert_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 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");
 }
@@ -827,10 +613,7 @@ fn c73_l298_assert_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 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");
 }
@@ -838,10 +621,7 @@ fn c74_l299_assert_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 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");
 }
@@ -849,10 +629,7 @@ fn c75_l300_assert_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 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");
 }
@@ -860,10 +637,7 @@ fn c76_l301_assert_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 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");
 }
@@ -871,10 +645,7 @@ fn c77_l302_assert_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 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");
 }
@@ -882,10 +653,7 @@ fn c78_l303_assert_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 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");
 }
@@ -893,10 +661,7 @@ fn c79_l304_assert_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 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");
 }
@@ -904,10 +669,7 @@ fn c80_l305_assert_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 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");
 }
@@ -915,10 +677,7 @@ fn c81_l306_assert_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 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");
 }
@@ -926,10 +685,7 @@ fn c82_l307_assert_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 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");
 }
@@ -937,10 +693,7 @@ fn c83_l308_assert_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 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");
 }
@@ -948,10 +701,7 @@ fn c84_l309_assert_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 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");
 }
@@ -959,10 +709,7 @@ fn c85_l310_assert_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 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");
 }
@@ -970,10 +717,7 @@ fn c86_l311_assert_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 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");
 }
@@ -981,10 +725,7 @@ fn c87_l312_assert_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 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");
 }
@@ -992,10 +733,7 @@ fn c88_l313_assert_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 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");
 }
@@ -1003,10 +741,7 @@ fn c89_l314_assert_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 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");
 }
@@ -1014,10 +749,7 @@ fn c90_l315_assert_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 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");
 }
@@ -1025,10 +757,7 @@ fn c91_l316_assert_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 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");
 }
@@ -1036,10 +765,7 @@ fn c92_l317_assert_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 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");
 }
@@ -1047,10 +773,7 @@ fn c93_l318_assert_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 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");
 }
@@ -1058,10 +781,7 @@ fn c94_l319_assert_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 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");
 }
@@ -1069,10 +789,7 @@ fn c95_l320_assert_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 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");
 }
@@ -1080,10 +797,7 @@ fn c96_l321_assert_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 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");
 }
@@ -1091,10 +805,7 @@ fn c97_l322_assert_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 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");
 }
@@ -1102,10 +813,7 @@ fn c98_l323_assert_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 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");
 }
@@ -1113,10 +821,7 @@ fn c99_l324_assert_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 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");
 }
@@ -1124,10 +829,7 @@ fn c100_l325_assert_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 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");
 }
@@ -1135,10 +837,7 @@ fn c101_l326_assert_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 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");
 }
@@ -1146,10 +845,7 @@ fn c102_l327_assert_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 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");
 }
@@ -1157,10 +853,7 @@ fn c103_l328_assert_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 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");
 }
@@ -1168,10 +861,7 @@ fn c104_l329_assert_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 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");
 }
@@ -1179,10 +869,7 @@ fn c105_l330_assert_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 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");
 }
@@ -1190,10 +877,7 @@ fn c106_l331_assert_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 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");
 }
@@ -1201,10 +885,7 @@ fn c107_l332_assert_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 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");
 }
@@ -1212,10 +893,7 @@ fn c108_l333_assert_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 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");
 }
@@ -1223,10 +901,7 @@ fn c109_l334_assert_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 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");
 }
@@ -1234,10 +909,7 @@ fn c110_l335_assert_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 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");
 }
@@ -1245,10 +917,7 @@ fn c111_l336_assert_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 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");
 }
@@ -1256,9 +925,7 @@ fn c112_l337_assert_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 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");
 }
@@ -1266,9 +933,7 @@ fn c113_l340_assert_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 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");
 }
@@ -1276,9 +941,7 @@ fn c114_l341_assert_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 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");
 }
@@ -1286,9 +949,7 @@ fn c115_l342_assert_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 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");
 }
@@ -1296,9 +957,7 @@ fn c116_l343_assert_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 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");
 }
@@ -1306,9 +965,7 @@ fn c117_l344_assert_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 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");
 }
@@ -1316,9 +973,7 @@ fn c118_l345_assert_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 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");
 }
@@ -1326,9 +981,7 @@ fn c119_l346_assert_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 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");
 }
@@ -1336,9 +989,7 @@ fn c120_l347_assert_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 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");
 }
@@ -1346,9 +997,7 @@ fn c121_l348_assert_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 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");
 }
@@ -1356,9 +1005,7 @@ fn c122_l349_assert_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 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");
 }
@@ -1366,9 +1013,7 @@ fn c123_l350_assert_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 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");
 }
@@ -1376,9 +1021,7 @@ fn c124_l351_assert_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 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");
 }
@@ -1386,9 +1029,7 @@ fn c125_l352_assert_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 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");
 }
@@ -1396,9 +1037,7 @@ fn c126_l353_assert_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 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");
 }
@@ -1406,9 +1045,7 @@ fn c127_l354_assert_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 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");
 }
@@ -1416,9 +1053,7 @@ fn c128_l355_assert_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 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");
 }
@@ -1426,9 +1061,7 @@ fn c129_l356_assert_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 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");
 }
@@ -1436,9 +1069,7 @@ fn c130_l357_assert_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 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");
 }
@@ -1446,9 +1077,7 @@ fn c131_l358_assert_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 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");
 }
@@ -1456,9 +1085,7 @@ fn c132_l359_assert_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 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");
 }
@@ -1466,9 +1093,7 @@ fn c133_l360_assert_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 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");
 }
@@ -1476,10 +1101,7 @@ fn c134_l361_assert_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 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");
 }
@@ -1487,10 +1109,7 @@ fn c135_l364_assert_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 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");
 }
@@ -1498,10 +1117,7 @@ fn c136_l365_assert_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 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");
 }
@@ -1509,10 +1125,7 @@ fn c137_l366_assert_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 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");
 }
@@ -1520,10 +1133,7 @@ fn c138_l367_assert_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 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");
 }
@@ -1531,10 +1141,7 @@ fn c139_l368_assert_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 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");
 }
@@ -1542,10 +1149,7 @@ fn c140_l369_assert_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 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");
 }
@@ -1553,10 +1157,7 @@ fn c141_l370_assert_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 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");
 }
@@ -1564,10 +1165,7 @@ fn c142_l371_assert_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 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");
 }
@@ -1575,10 +1173,7 @@ fn c143_l372_assert_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 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");
 }
@@ -1586,10 +1181,7 @@ fn c144_l373_assert_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 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");
 }
@@ -1597,10 +1189,7 @@ fn c145_l374_assert_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 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");
 }
@@ -1608,10 +1197,7 @@ fn c146_l375_assert_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 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");
 }
@@ -1619,10 +1205,7 @@ fn c147_l376_assert_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 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");
 }
@@ -1630,10 +1213,7 @@ fn c148_l377_assert_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 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");
 }
@@ -1641,10 +1221,7 @@ fn c149_l378_assert_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 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");
 }
@@ -1652,10 +1229,7 @@ fn c150_l379_assert_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 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");
 }
@@ -1663,10 +1237,7 @@ fn c151_l380_assert_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 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");
 }
@@ -1674,10 +1245,7 @@ fn c152_l381_assert_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 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");
 }
@@ -1685,10 +1253,7 @@ fn c153_l382_assert_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 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");
 }
@@ -1696,10 +1261,7 @@ fn c154_l383_assert_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 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");
 }
@@ -1707,10 +1269,7 @@ fn c155_l384_assert_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 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");
 }
@@ -1718,10 +1277,7 @@ fn c156_l385_assert_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 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");
 }
@@ -1729,10 +1285,7 @@ fn c157_l386_assert_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 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");
 }
@@ -1740,10 +1293,7 @@ fn c158_l387_assert_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 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");
 }
@@ -1751,10 +1301,7 @@ fn c159_l388_assert_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 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");
 }
@@ -1762,10 +1309,7 @@ fn c160_l389_assert_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 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");
 }
@@ -1773,10 +1317,7 @@ fn c161_l390_assert_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 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");
 }
@@ -1784,10 +1325,7 @@ fn c162_l391_assert_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 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");
 }
@@ -1795,10 +1333,7 @@ fn c163_l392_assert_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 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");
 }
@@ -1806,10 +1341,7 @@ fn c164_l393_assert_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 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");
 }
@@ -1817,10 +1349,7 @@ fn c165_l394_assert_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 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");
 }
@@ -1828,10 +1357,7 @@ fn c166_l395_assert_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 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");
 }
@@ -1839,9 +1365,7 @@ fn c167_l398_assert_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 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");
 }
@@ -1849,9 +1373,7 @@ fn c168_l399_assert_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 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");
 }
@@ -1859,9 +1381,7 @@ fn c169_l400_assert_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 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");
 }
@@ -1869,9 +1389,7 @@ fn c170_l401_assert_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 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");
 }
@@ -1879,9 +1397,7 @@ fn c171_l402_assert_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 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");
 }
@@ -1889,10 +1405,7 @@ fn c172_l403_assert_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 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");
 }
@@ -1900,10 +1413,7 @@ fn c173_l404_assert_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 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");
 }
@@ -1911,9 +1421,7 @@ fn c174_l405_assert_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 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");
 }
@@ -1921,9 +1429,7 @@ fn c175_l406_assert_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 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");
 }
@@ -1931,9 +1437,7 @@ fn c176_l407_assert_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 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");
 }
@@ -1941,9 +1445,7 @@ fn c177_l408_assert_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 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");
 }
@@ -1951,9 +1453,7 @@ fn c178_l409_assert_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 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");
 }
@@ -1961,9 +1461,7 @@ fn c179_l410_assert_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 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");
 }
@@ -1971,9 +1469,7 @@ fn c180_l411_assert_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 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");
 }
@@ -1981,9 +1477,7 @@ fn c181_l412_assert_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 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");
 }
@@ -1991,9 +1485,7 @@ fn c182_l413_assert_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 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");
 }
@@ -2001,9 +1493,7 @@ fn c183_l414_assert_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 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");
 }
@@ -2011,9 +1501,7 @@ fn c184_l415_assert_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 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");
 }
@@ -2021,9 +1509,7 @@ fn c185_l416_assert_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 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");
 }
@@ -2031,9 +1517,7 @@ fn c186_l417_assert_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 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");
 }
@@ -2041,9 +1525,7 @@ fn c187_l418_assert_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 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");
 }
@@ -2051,9 +1533,7 @@ fn c188_l419_assert_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 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");
 }
@@ -2061,9 +1541,7 @@ fn c189_l420_assert_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 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");
 }
@@ -2071,9 +1549,7 @@ fn c190_l421_assert_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 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");
 }
@@ -2081,10 +1557,7 @@ fn c191_l422_assert_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 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
index ddc78be35..f15aa61ff 100644
--- a/lib/runtime/tests/spectests/types.rs
+++ b/lib/runtime/tests/spectests/types.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func))
@@ -33,11 +37,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -48,29 +49,17 @@ fn start_module_1(instance: &mut Instance) {
 // 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 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"
-    );
+    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 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"
-    );
+    assert!(compilation.is_err(), "WASM should not compile as is malformed");
 }
 
 // Line 53
diff --git a/lib/runtime/tests/spectests/unwind.rs b/lib/runtime/tests/spectests/unwind.rs
index d7e5451b2..44b06e450 100644
--- a/lib/runtime/tests/spectests/unwind.rs
+++ b/lib/runtime/tests/spectests/unwind.rs
@@ -5,17 +5,21 @@
     warnings,
     dead_code
 )]
-use std::{f32, f64};
 use wabt::wat2wasm;
+use std::{f32, f64};
 
-use wasmer_clif_backend::CraneliftCompiler;
 use wasmer_runtime::types::Value;
-use wasmer_runtime::{module::Module, Instance};
+use wasmer_runtime::{Instance, module::Module};
+use wasmer_clif_backend::CraneliftCompiler;
+
+use crate::spectests::_common::{
+    generate_imports,
+    NaNCheck,
+};
 
-use crate::spectests::_common::{generate_imports, NaNCheck};
 
 // Line 3
-fn create_module_1() -> Box<Instance> {
+fn create_module_1() -> Instance {
     let module_str = "(module
       (type (;0;) (func))
       (type (;1;) (func (result i32)))
@@ -442,11 +446,8 @@ fn create_module_1() -> Box<Instance> {
       (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(generate_imports())
-        .expect("WASM can't be instantiated")
+    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
+    module.instantiate(generate_imports()).expect("WASM can't be instantiated")
 }
 
 fn start_module_1(instance: &mut Instance) {
@@ -458,14 +459,14 @@ fn start_module_1(instance: &mut Instance) {
 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);
+    let result = c1_l212_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -529,14 +530,14 @@ fn c8_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c9_l221_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -600,14 +601,14 @@ fn c16_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c17_l230_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -671,14 +672,14 @@ fn c24_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c25_l239_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -718,14 +719,14 @@ fn c29_l243_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c30_l245_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -765,14 +766,14 @@ fn c34_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c35_l251_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -812,14 +813,14 @@ fn c39_l255_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c40_l257_action_invoke(&mut instance);
     assert!(result.is_err());
 }
 
@@ -859,14 +860,14 @@ fn c44_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
 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);
+    let result = c45_l263_action_invoke(&mut instance);
     assert!(result.is_err());
 }