// Rust test file autogenerated with cargo build (build/spectests.rs).
// Please do NOT modify it by hand, as it will be reset on next build.
// Test based on spectests/float_misc.wast
#![allow(
    warnings,
    dead_code
)]
use wabt::wat2wasm;
use std::{f32, f64};

use wasmer_runtime::types::Value;
use wasmer_runtime::{Instance, module::Module};
use wasmer_clif_backend::CraneliftCompiler;

use crate::spectests::_common::{
    spectest_importobject,
    NaNCheck,
};


// Line 17
fn create_module_1() -> Box<Instance> {
    let module_str = "(module
      (type (;0;) (func (param f32 f32) (result f32)))
      (type (;1;) (func (param f32) (result f32)))
      (type (;2;) (func (param f64 f64) (result f64)))
      (type (;3;) (func (param f64) (result f64)))
      (func (;0;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.add)
      (func (;1;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.sub)
      (func (;2;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.mul)
      (func (;3;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.div)
      (func (;4;) (type 1) (param f32) (result f32)
        get_local 0
        f32.sqrt)
      (func (;5;) (type 1) (param f32) (result f32)
        get_local 0
        f32.abs)
      (func (;6;) (type 1) (param f32) (result f32)
        get_local 0
        f32.neg)
      (func (;7;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.copysign)
      (func (;8;) (type 1) (param f32) (result f32)
        get_local 0
        f32.ceil)
      (func (;9;) (type 1) (param f32) (result f32)
        get_local 0
        f32.floor)
      (func (;10;) (type 1) (param f32) (result f32)
        get_local 0
        f32.trunc)
      (func (;11;) (type 1) (param f32) (result f32)
        get_local 0
        f32.nearest)
      (func (;12;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.min)
      (func (;13;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.max)
      (func (;14;) (type 2) (param f64 f64) (result f64)
        get_local 0
        get_local 1
        f64.add)
      (func (;15;) (type 2) (param f64 f64) (result f64)
        get_local 0
        get_local 1
        f64.sub)
      (func (;16;) (type 2) (param f64 f64) (result f64)
        get_local 0
        get_local 1
        f64.mul)
      (func (;17;) (type 2) (param f64 f64) (result f64)
        get_local 0
        get_local 1
        f64.div)
      (func (;18;) (type 3) (param f64) (result f64)
        get_local 0
        f64.sqrt)
      (func (;19;) (type 3) (param f64) (result f64)
        get_local 0
        f64.abs)
      (func (;20;) (type 3) (param f64) (result f64)
        get_local 0
        f64.neg)
      (func (;21;) (type 2) (param f64 f64) (result f64)
        get_local 0
        get_local 1
        f64.copysign)
      (func (;22;) (type 3) (param f64) (result f64)
        get_local 0
        f64.ceil)
      (func (;23;) (type 3) (param f64) (result f64)
        get_local 0
        f64.floor)
      (func (;24;) (type 3) (param f64) (result f64)
        get_local 0
        f64.trunc)
      (func (;25;) (type 3) (param f64) (result f64)
        get_local 0
        f64.nearest)
      (func (;26;) (type 2) (param f64 f64) (result f64)
        get_local 0
        get_local 1
        f64.min)
      (func (;27;) (type 2) (param f64 f64) (result f64)
        get_local 0
        get_local 1
        f64.max)
      (export \"f32.add\" (func 0))
      (export \"f32.sub\" (func 1))
      (export \"f32.mul\" (func 2))
      (export \"f32.div\" (func 3))
      (export \"f32.sqrt\" (func 4))
      (export \"f32.abs\" (func 5))
      (export \"f32.neg\" (func 6))
      (export \"f32.copysign\" (func 7))
      (export \"f32.ceil\" (func 8))
      (export \"f32.floor\" (func 9))
      (export \"f32.trunc\" (func 10))
      (export \"f32.nearest\" (func 11))
      (export \"f32.min\" (func 12))
      (export \"f32.max\" (func 13))
      (export \"f64.add\" (func 14))
      (export \"f64.sub\" (func 15))
      (export \"f64.mul\" (func 16))
      (export \"f64.div\" (func 17))
      (export \"f64.sqrt\" (func 18))
      (export \"f64.abs\" (func 19))
      (export \"f64.neg\" (func 20))
      (export \"f64.copysign\" (func 21))
      (export \"f64.ceil\" (func 22))
      (export \"f64.floor\" (func 23))
      (export \"f64.trunc\" (func 24))
      (export \"f64.nearest\" (func 25))
      (export \"f64.min\" (func 26))
      (export \"f64.max\" (func 27)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
    module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_1(instance: &mut Instance) {
    // TODO Review is explicit start needed? Start now called in runtime::Instance::new()
    //instance.start();
}

// Line 50
fn c1_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1_l50_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((1.1234568f32).to_bits()), Value::F32((0.00000000012345f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.1234568f32).to_bits()))));
    result.map(|_| ())
}

// Line 51
fn c2_l51_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2_l51_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((1.123456789f64).to_bits()), Value::F64((0.00000000012345f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.12345678912345f64).to_bits()))));
    result.map(|_| ())
}

// Line 55
fn c3_l55_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c3_l55_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000059604645f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 56
fn c4_l56_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c4_l56_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.00000005960465f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 57
fn c5_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c5_l57_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000011102230246251565f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 58
fn c6_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c6_l58_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000011102230246251568f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits()))));
    result.map(|_| ())
}

// Line 61
fn c7_l61_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c7_l61_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 62
fn c8_l62_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c8_l62_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()))));
    result.map(|_| ())
}

// Line 67
fn c9_l67_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c9_l67_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((2147483600.0f32).to_bits()), Value::F32((1024.25f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2147484700.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 68
fn c10_l68_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c10_l68_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((9223372036854776000.0f64).to_bits()), Value::F64((1024.25f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 72
fn c11_l72_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c11_l72_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645561009778199f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000292f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036455610097781983f64).to_bits()))));
    result.map(|_| ())
}

// Line 75
fn c12_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c12_l75_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((9007199254740992.0f64).to_bits()), Value::F64((1.00001f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((9007199254740994.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 78
fn c13_l78_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c13_l78_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((9007199254740994.0f64).to_bits()), Value::F64((0.9999847412109375f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((9007199254740994.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 81
fn c14_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c14_l81_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((8388608.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 82
fn c15_l82_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c15_l82_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((8388609.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388610.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 83
fn c16_l83_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c16_l83_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((4503599627370496.0f64).to_bits()), Value::F64((0.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 84
fn c17_l84_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c17_l84_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((4503599627370497.0f64).to_bits()), Value::F64((0.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4503599627370498.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 87
fn c18_l87_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c18_l87_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-6207600000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000002309799f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6207600000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 88
fn c19_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c19_l88_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((209865800000000000000.0f32).to_bits()), Value::F32((-5270152500000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((209860530000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 89
fn c20_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c20_l89_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.0000000000000000000000001963492f32).to_bits()), Value::F32((0.000000000000000000000000000000000000046220067f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000001963492f32).to_bits()))));
    result.map(|_| ())
}

// Line 90
fn c21_l90_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c21_l90_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((640905000000.0f32).to_bits()), Value::F32((-64449550000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-64448910000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 91
fn c22_l91_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c22_l91_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.0000601966f32).to_bits()), Value::F32((120372790000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((120372790000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 92
fn c23_l92_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c23_l92_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009218993827002741f64).to_bits()), Value::F64((-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 93
fn c24_l93_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c24_l93_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-96503407870148960000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000004670208988478548f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-96503407870148960000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 94
fn c25_l94_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c25_l94_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.0000000000000000000000000000000000000000000028559147675434106f64).to_bits()), Value::F64((-0.00026124280570653086f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00026124280570653086f64).to_bits()))));
    result.map(|_| ())
}

// Line 95
fn c26_l95_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c26_l95_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((79335564741512700000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 96
fn c27_l96_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c27_l96_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((8265442868747023000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 99
fn c28_l99_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c28_l99_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((5238404000000000000000.0f32).to_bits()), Value::F32((-1570182.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5238404000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 100
fn c29_l100_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c29_l100_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.00000000000004258938f32).to_bits()), Value::F32((-0.0000000000000000000000057092353f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000004258938f32).to_bits()))));
    result.map(|_| ())
}

// Line 101
fn c30_l101_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c30_l101_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-0.00000000000027251026f32).to_bits()), Value::F32((83711560000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((83711560000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 102
fn c31_l102_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c31_l102_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-0.0000000000000884536f32).to_bits()), Value::F32((-0.000000000000000000000000000000015165626f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000884536f32).to_bits()))));
    result.map(|_| ())
}

// Line 103
fn c32_l103_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c32_l103_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.0010521035f32).to_bits()), Value::F32((-0.000000000000000000000000000000007582135f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0010521035f32).to_bits()))));
    result.map(|_| ())
}

// Line 104
fn c33_l104_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c33_l104_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((1511135228188924600000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002760218100603169f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1511135228188924600000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 105
fn c34_l105_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c34_l105_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((62386719760360280000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000008592185488839212f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((62386719760360280000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 106
fn c35_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c35_l106_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029225342022551453f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354f64).to_bits()))));
    result.map(|_| ())
}

// Line 107
fn c36_l107_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c36_l107_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-215220546714824520000000000000000000000000000.0f64).to_bits()), Value::F64((-1112220412047137200000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-216332767126871650000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 108
fn c37_l108_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c37_l108_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-13.6911535055856f64).to_bits()), Value::F64((2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 111
fn c38_l111_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c38_l111_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000006456021f32).to_bits()), Value::F32((0.00000000000020219949f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000020219949f32).to_bits()))));
    result.map(|_| ())
}

// Line 112
fn c39_l112_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c39_l112_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-0.000026823169f32).to_bits()), Value::F32((0.000000011196016f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000026811973f32).to_bits()))));
    result.map(|_| ())
}

// Line 113
fn c40_l113_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c40_l113_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-128526170000.0f32).to_bits()), Value::F32((0.0000000000000000000000000000000027356305f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-128526170000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 114
fn c41_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c41_l114_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000004158973f32).to_bits()), Value::F32((-1573528700.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1573528700.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 115
fn c42_l115_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c42_l115_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-0.0000000000000000000000000000000000009338769f32).to_bits()), Value::F32((78647514000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((78647514000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 116
fn c43_l116_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c43_l116_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021986596650683218f64).to_bits()), Value::F64((-235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 117
fn c44_l117_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c44_l117_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-314175619593595700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-30114098514611660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-314175649707694230000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 118
fn c45_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c45_l118_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013722858367681836f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977f64).to_bits()))));
    result.map(|_| ())
}

// Line 119
fn c46_l119_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c46_l119_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016862581574752944f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075f64).to_bits()))));
    result.map(|_| ())
}

// Line 120
fn c47_l120_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c47_l120_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((8374007930974482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 123
fn c48_l123_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c48_l123_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-210896605327889950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((581483233421196300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((581483022524591100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 124
fn c49_l124_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c49_l124_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((102315792666821480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((450204300797494900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((102315792667271680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 125
fn c50_l125_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c50_l125_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-130529978570956560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((154899434220186570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((154899434220186450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 126
fn c51_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c51_l126_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((47629997434721684000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 127
fn c52_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c52_l127_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003958952516558414f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023092460710062946f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000230924607140219f64).to_bits()))));
    result.map(|_| ())
}

// Line 130
fn c53_l130_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c53_l130_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-43780558475415996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 131
fn c54_l131_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c54_l131_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((21174311168546080000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-26385928474612128000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-26385928474612128000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 132
fn c55_l132_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c55_l132_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007858068235728165f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 133
fn c56_l133_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c56_l133_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005079144928553737f64).to_bits()), Value::F64((-354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 134
fn c57_l134_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c57_l134_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010865942283516648f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64).to_bits()))));
    result.map(|_| ())
}

// Line 137
fn c58_l137_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c58_l137_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((97215650000000000000000000000000000.0f32).to_bits()), Value::F32((305590870000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((305688080000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 138
fn c59_l138_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c59_l138_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((270465630000000000000000000000000000000.0f32).to_bits()), Value::F32((-230236850000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((270465400000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 139
fn c60_l139_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c60_l139_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((357209300000000000000000000000000000.0f32).to_bits()), Value::F32((-236494050000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-236136840000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 140
fn c61_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c61_l140_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-1484234100000000000000000000000000000.0f32).to_bits()), Value::F32((-328991400000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-330475620000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 141
fn c62_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c62_l141_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-219885600000000000000000000000000000000.0f32).to_bits()), Value::F32((-81560930000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-301446520000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 142
fn c63_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c63_l142_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((90390204939547630000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((22943337422040356000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((90390204939570580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 143
fn c64_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c64_l143_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((165916059736246050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((12577349331444160000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((165916059748823400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 144
fn c65_l144_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c65_l144_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-136351292561394300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((60507030603873580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-136290785530790440000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 145
fn c66_l145_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c66_l145_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-34377613258227424000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((169947152758793490000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((169947118381180220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 146
fn c67_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c67_l146_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((92273427008645570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-39269416451018680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((92273426969376150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 149
fn c68_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c68_l149_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000008313455f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000873f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000008314328f32).to_bits()))));
    result.map(|_| ())
}

// Line 150
fn c69_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c69_l150_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000052f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000049f32).to_bits()))));
    result.map(|_| ())
}

// Line 151
fn c70_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c70_l151_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000000000000011f32).to_bits()), Value::F32((0.000000000000000000000000000000000000005186284f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005186273f32).to_bits()))));
    result.map(|_| ())
}

// Line 152
fn c71_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c71_l152_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000000000000028f32).to_bits()), Value::F32((0.00000000000000000000000000000000000023675283f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000002367528f32).to_bits()))));
    result.map(|_| ())
}

// Line 153
fn c72_l153_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c72_l153_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000635f32).to_bits()), Value::F32((-0.00000000000000000000000000000000000000003327f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000032635f32).to_bits()))));
    result.map(|_| ())
}

// Line 154
fn c73_l154_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c73_l154_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028461489375936755f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005130160608603642f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002284011671009967f64).to_bits()))));
    result.map(|_| ())
}

// Line 155
fn c74_l155_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c74_l155_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047404811354775f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008895417776504167f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004154936641026667f64).to_bits()))));
    result.map(|_| ())
}

// Line 156
fn c75_l156_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c75_l156_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009330082001250494f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029863980609419717f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003919406261067021f64).to_bits()))));
    result.map(|_| ())
}

// Line 157
fn c76_l157_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c76_l157_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014418693884494008f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016324914377759187f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001906220493265178f64).to_bits()))));
    result.map(|_| ())
}

// Line 158
fn c77_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c77_l158_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043203619362281506f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002521511966399844f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017988499698283067f64).to_bits()))));
    result.map(|_| ())
}

// Line 162
fn c78_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c78_l162_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((340282330000000000000000000000000000000.0f32).to_bits()), Value::F32((20282410000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 163
fn c79_l163_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c79_l163_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((19958403095347200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 166
fn c80_l166_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c80_l166_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((2.0f32).to_bits()), Value::F32((2.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((4.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 167
fn c81_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c81_l167_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((2.0f64).to_bits()), Value::F64((2.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 170
fn c82_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c82_l170_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((10141204000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 171
fn c83_l171_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c83_l171_action_invoke");
    let result = instance.call("f32.add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((10141205000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 172
fn c84_l172_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c84_l172_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 173
fn c85_l173_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c85_l173_action_invoke");
    let result = instance.call("f64.add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 177
fn c86_l177_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c86_l177_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((65536.0f32).to_bits()), Value::F32((0.000000000007275958f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((65536.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 178
fn c87_l178_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c87_l178_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((65536.0f64).to_bits()), Value::F64((0.000000000007275957614183426f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((65535.99999999999f64).to_bits()))));
    result.map(|_| ())
}

// Line 182
fn c88_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c88_l182_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000029802322f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 183
fn c89_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c89_l183_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000029802326f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.99999994f32).to_bits()))));
    result.map(|_| ())
}

// Line 184
fn c90_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c90_l184_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000005551115123125783f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 185
fn c91_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c91_l185_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000005551115123125784f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.9999999999999999f64).to_bits()))));
    result.map(|_| ())
}

// Line 188
fn c92_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c92_l188_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((0.00000000000000000000000000000002379208f32).to_bits()), Value::F32((-722129800000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((722129800000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 189
fn c93_l189_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c93_l189_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-842284000000000000000000000000000000.0f32).to_bits()), Value::F32((-11118414000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-842284000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 190
fn c94_l190_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c94_l190_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((1.4549444f32).to_bits()), Value::F32((-0.00000000000000000000000033792615f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.4549444f32).to_bits()))));
    result.map(|_| ())
}

// Line 191
fn c95_l191_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c95_l191_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((0.0000000000000000000000000000000000094808914f32).to_bits()), Value::F32((0.000000000000000000000018589502f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000018589502f32).to_bits()))));
    result.map(|_| ())
}

// Line 192
fn c96_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c96_l192_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((0.000006181167f32).to_bits()), Value::F32((-0.0000000000000000000000000000000093959864f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000006181167f32).to_bits()))));
    result.map(|_| ())
}

// Line 193
fn c97_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c97_l193_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002524845082116609f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413f64).to_bits()))));
    result.map(|_| ())
}

// Line 194
fn c98_l194_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c98_l194_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000038165079778426864f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 195
fn c99_l195_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c99_l195_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020889465194336087f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332f64).to_bits()))));
    result.map(|_| ())
}

// Line 196
fn c100_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c100_l196_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000303879528930943f64).to_bits()), Value::F64((-23204941114021897000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((23204941114021897000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 197
fn c101_l197_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c101_l197_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.00000000000000000000000000000000000000000014953904039036317f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010592252695645683f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000014953904039036317f64).to_bits()))));
    result.map(|_| ())
}

// Line 200
fn c102_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c102_l200_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-448601660000000000000000000000000.0f32).to_bits()), Value::F32((-8984148000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8535546400000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 201
fn c103_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c103_l201_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-899427400000000000000000000000000.0f32).to_bits()), Value::F32((91.579384f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-899427400000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 202
fn c104_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c104_l202_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-0.00000000000000000000000011975f32).to_bits()), Value::F32((0.000000063140405f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000063140405f32).to_bits()))));
    result.map(|_| ())
}

// Line 203
fn c105_l203_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c105_l203_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-0.000000000000000000000011800487f32).to_bits()), Value::F32((-0.00031558736f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00031558736f32).to_bits()))));
    result.map(|_| ())
}

// Line 204
fn c106_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c106_l204_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-736483800000000000000000000000.0f32).to_bits()), Value::F32((0.0000000000000000030824513f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-736483800000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 205
fn c107_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c107_l205_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-9410469964196796000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 206
fn c108_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c108_l206_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002339448785991429f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173f64).to_bits()))));
    result.map(|_| ())
}

// Line 207
fn c109_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c109_l207_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001572015082308034f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64).to_bits()))));
    result.map(|_| ())
}

// Line 208
fn c110_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c110_l208_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034908896031751274f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208f64).to_bits()))));
    result.map(|_| ())
}

// Line 209
fn c111_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c111_l209_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-7538298763725556000000000000000000.0f64).to_bits()), Value::F64((4447012580193329000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-4447012580193329000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 212
fn c112_l212_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c112_l212_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((75846976000000000000000000000.0f32).to_bits()), Value::F32((0.000046391753f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((75846976000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 213
fn c113_l213_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c113_l213_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-567139.9f32).to_bits()), Value::F32((-0.000000000030334842f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-567139.9f32).to_bits()))));
    result.map(|_| ())
}

// Line 214
fn c114_l214_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c114_l214_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-0.000000000017412261f32).to_bits()), Value::F32((-0.000000000000000017877793f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000017412244f32).to_bits()))));
    result.map(|_| ())
}

// Line 215
fn c115_l215_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c115_l215_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-0.000065645545f32).to_bits()), Value::F32((0.00014473806f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00021038362f32).to_bits()))));
    result.map(|_| ())
}

// Line 216
fn c116_l216_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c116_l216_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((-0.00000000016016115f32).to_bits()), Value::F32((-0.000000000000000000000000000000085380075f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000000016016115f32).to_bits()))));
    result.map(|_| ())
}

// Line 217
fn c117_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c117_l217_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.000000000000000000000000000000000000000000000009358725267183177f64).to_bits()), Value::F64((-31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 218
fn c118_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c118_l218_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-4390767596767215000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 219
fn c119_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c119_l219_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036288281010831153f64).to_bits()), Value::F64((3383199683245004400000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-3383199683245004400000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 220
fn c120_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c120_l220_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645097751812619f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423490969686624f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423491006137603f64).to_bits()))));
    result.map(|_| ())
}

// Line 221
fn c121_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c121_l221_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008021529638989887f64).to_bits()), Value::F64((-0.00006774972769072139f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00006774972769072139f64).to_bits()))));
    result.map(|_| ())
}

// Line 224
fn c122_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c122_l224_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000005816988065793039f64).to_bits()), Value::F64((0.000000000000000000000000000000000025021499241540866f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000005816988065768018f64).to_bits()))));
    result.map(|_| ())
}

// Line 225
fn c123_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c123_l225_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683304809554f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016945582607476316f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683135353726f64).to_bits()))));
    result.map(|_| ())
}

// Line 226
fn c124_l226_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c124_l226_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000006908052676315257f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64).to_bits()))));
    result.map(|_| ())
}

// Line 227
fn c125_l227_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c125_l227_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.0000000000022044291547443813f64).to_bits()), Value::F64((-0.0000000000000000000027947429925618632f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.000000000002204429151949638f64).to_bits()))));
    result.map(|_| ())
}

// Line 228
fn c126_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c126_l228_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.00000004016393569117761f64).to_bits()), Value::F64((0.17053881989395447f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.17053877973001877f64).to_bits()))));
    result.map(|_| ())
}

// Line 231
fn c127_l231_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c127_l231_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010015106898667285f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004785375958943186f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047853759589431757f64).to_bits()))));
    result.map(|_| ())
}

// Line 232
fn c128_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c128_l232_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((-15618959953.641388f64).to_bits()), Value::F64((598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 233
fn c129_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c129_l233_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((38832071540376680000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042192279274320304f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((38832071540376680000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 234
fn c130_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c130_l234_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017466607734737216f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897f64).to_bits()))));
    result.map(|_| ())
}

// Line 235
fn c131_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c131_l235_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000949378346261834f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014584885434950294f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000949378346261834f64).to_bits()))));
    result.map(|_| ())
}

// Line 239
fn c132_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c132_l239_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((23.140692f32).to_bits()), Value::F32((3.1415927f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((19.9991f32).to_bits()))));
    result.map(|_| ())
}

// Line 240
fn c133_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c133_l240_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((23.14069263277927f64).to_bits()), Value::F64((3.141592653589793f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((19.999099979189477f64).to_bits()))));
    result.map(|_| ())
}

// Line 243
fn c134_l243_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c134_l243_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((2999999.0f32).to_bits()), Value::F32((2999998.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 244
fn c135_l244_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c135_l244_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((1999999.0f32).to_bits()), Value::F32((1999995.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((4.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 245
fn c136_l245_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c136_l245_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((1999999.0f32).to_bits()), Value::F32((1999993.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 246
fn c137_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c137_l246_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((400002.0f32).to_bits()), Value::F32((400001.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 247
fn c138_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c138_l247_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((400002.0f32).to_bits()), Value::F32((400000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 248
fn c139_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c139_l248_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((2999999999999999.0f64).to_bits()), Value::F64((2999999999999998.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 249
fn c140_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c140_l249_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((1999999999999999.0f64).to_bits()), Value::F64((1999999999999995.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 250
fn c141_l250_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c141_l250_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((1999999999999999.0f64).to_bits()), Value::F64((1999999999999993.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((6.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 251
fn c142_l251_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c142_l251_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((400000000000002.0f64).to_bits()), Value::F64((400000000000001.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 252
fn c143_l252_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c143_l252_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((400000000000002.0f64).to_bits()), Value::F64((400000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 255
fn c144_l255_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c144_l255_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 256
fn c145_l256_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c145_l256_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()))));
    result.map(|_| ())
}

// Line 259
fn c146_l259_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c146_l259_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((1.0000001f32).to_bits()), Value::F32((0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000017881393f32).to_bits()))));
    result.map(|_| ())
}

// Line 260
fn c147_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c147_l260_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((1.0000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32).to_bits()))));
    result.map(|_| ())
}

// Line 261
fn c148_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c148_l261_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000059604645f32).to_bits()))));
    result.map(|_| ())
}

// Line 262
fn c149_l262_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c149_l262_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000033306690738754696f64).to_bits()))));
    result.map(|_| ())
}

// Line 263
fn c150_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c150_l263_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((1.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64).to_bits()))));
    result.map(|_| ())
}

// Line 264
fn c151_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c151_l264_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000011102230246251565f64).to_bits()))));
    result.map(|_| ())
}

// Line 268
fn c152_l268_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c152_l268_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((10141204000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 269
fn c153_l269_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c153_l269_action_invoke");
    let result = instance.call("f32.sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((10141205000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 270
fn c154_l270_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c154_l270_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 271
fn c155_l271_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c155_l271_action_invoke");
    let result = instance.call("f64.sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 274
fn c156_l274_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c156_l274_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((1000000000000000.0f32).to_bits()), Value::F32((1000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((999999940000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 275
fn c157_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c157_l275_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((100000000000000000000.0f32).to_bits()), Value::F32((100000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 276
fn c158_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c158_l276_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((10000000000000000000000000.0f32).to_bits()), Value::F32((10000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 277
fn c159_l277_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c159_l277_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((1000000000000000.0f64).to_bits()), Value::F64((1000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 278
fn c160_l278_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c160_l278_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((100000000000000000000.0f64).to_bits()), Value::F64((100000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((10000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 279
fn c161_l279_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c161_l279_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((10000000000000000000000000.0f64).to_bits()), Value::F64((10000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((100000000000000030000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 284
fn c162_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c162_l284_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((1848874900.0f32).to_bits()), Value::F32((19954563000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((36893493000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 285
fn c163_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c163_l285_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((1848874847.0f64).to_bits()), Value::F64((19954562207.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((36893488147419110000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 289
fn c164_l289_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c164_l289_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((77.1f32).to_bits()), Value::F32((850.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((65535.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 290
fn c165_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c165_l290_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((77.1f64).to_bits()), Value::F64((850.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((65534.99999999999f64).to_bits()))));
    result.map(|_| ())
}

// Line 293
fn c166_l293_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c166_l293_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-2493839400000000000.0f32).to_bits()), Value::F32((0.000000000021176054f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-52809680.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 294
fn c167_l294_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c167_l294_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-6777248400000000000000000000000.0f32).to_bits()), Value::F32((-0.00000000000000000000000000000034758242f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2.3556523f32).to_bits()))));
    result.map(|_| ())
}

// Line 295
fn c168_l295_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c168_l295_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-8384397600000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000011948991f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.10018509f32).to_bits()))));
    result.map(|_| ())
}

// Line 296
fn c169_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c169_l296_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-656765400000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000046889766f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((30.795576f32).to_bits()))));
    result.map(|_| ())
}

// Line 297
fn c170_l297_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c170_l297_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((13328204000000000.0f32).to_bits()), Value::F32((45.567223f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((607329200000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 298
fn c171_l298_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c171_l298_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-99426226093342430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((583177241514245140000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 299
fn c172_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c172_l299_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002748155824301909f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000002093035437779455f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 300
fn c173_l300_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c173_l300_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((464888257371302500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-159272886487254360000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-74044094645556960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 301
fn c174_l301_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c174_l301_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008261927764172427f64).to_bits()), Value::F64((36684744190529535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-3030867065492991300000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 302
fn c175_l302_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c175_l302_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((253838958331769250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007842892881810105f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000019908317594263248f64).to_bits()))));
    result.map(|_| ())
}

// Line 305
fn c176_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c176_l305_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-0.0000000000000000000000000020153333f32).to_bits()), Value::F32((-5031353000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((10.139854f32).to_bits()))));
    result.map(|_| ())
}

// Line 306
fn c177_l306_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c177_l306_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((12286325000000000000000.0f32).to_bits()), Value::F32((749601.8f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((9209852000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 307
fn c178_l307_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c178_l307_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-0.0000000002763514f32).to_bits()), Value::F32((-35524714000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((9817304000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 308
fn c179_l308_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c179_l308_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((218931220000000000000.0f32).to_bits()), Value::F32((-40298.785f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-8822662000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 309
fn c180_l309_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c180_l309_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((1691996300.0f32).to_bits()), Value::F32((-122103350000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-206598410000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 310
fn c181_l310_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c181_l310_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007576316076452304f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004601355879514986f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003486132652344772f64).to_bits()))));
    result.map(|_| ())
}

// Line 311
fn c182_l311_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c182_l311_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012228616081443885f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008055526185180067f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009850793705258527f64).to_bits()))));
    result.map(|_| ())
}

// Line 312
fn c183_l312_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c183_l312_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-2068651246039250800000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-366801071583254800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 313
fn c184_l313_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c184_l313_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((1543238835610281000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007370621385787007f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1137462916512617700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 314
fn c185_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c185_l314_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((2235876566242058700000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-760669005920257000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-1700762005003744000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 317
fn c186_l317_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c186_l317_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-110087030000000.0f32).to_bits()), Value::F32((-54038020000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 318
fn c187_l318_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c187_l318_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-0.19366351f32).to_bits()), Value::F32((0.0000000000000000000000000000029748954f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000000005761287f32).to_bits()))));
    result.map(|_| ())
}

// Line 319
fn c188_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c188_l319_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-0.0000034300713f32).to_bits()), Value::F32((77991523000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-267516490000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 320
fn c189_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c189_l320_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-99003850000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000020933774f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000020725242f32).to_bits()))));
    result.map(|_| ())
}

// Line 321
fn c190_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c190_l321_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-129919.07f32).to_bits()), Value::F32((0.0000000000000000000000000000000000018480999f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000024010342f32).to_bits()))));
    result.map(|_| ())
}

// Line 322
fn c191_l322_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c191_l322_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006625572200844895f64).to_bits()), Value::F64((-37374020681740010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000024762427246273877f64).to_bits()))));
    result.map(|_| ())
}

// Line 323
fn c192_l323_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c192_l323_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((821076848561758000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012976552328552289f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000010654746691124455f64).to_bits()))));
    result.map(|_| ())
}

// Line 324
fn c193_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c193_l324_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-10223449294906041000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1970855583334680500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-20148942123804574000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 325
fn c194_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c194_l325_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((2918243080119086000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-63633170941689700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 326
fn c195_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c195_l326_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((3407037798802672000000000.0f64).to_bits()), Value::F64((1225791423971563000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4176317714919266400000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 329
fn c196_l329_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c196_l329_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044091927284399547f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011518840702296592f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005078878866462432f64).to_bits()))));
    result.map(|_| ())
}

// Line 330
fn c197_l330_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c197_l330_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.002980041826472432f64).to_bits()), Value::F64((63125412993218000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-188116371033135940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 331
fn c198_l331_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c198_l331_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-308344578081300100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010081049555008529f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000031084369716557833f64).to_bits()))));
    result.map(|_| ())
}

// Line 332
fn c199_l332_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c199_l332_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((349387501315677300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((2131316915930809900.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((744655491768901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 333
fn c200_l333_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c200_l333_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012500108005100234f64).to_bits()), Value::F64((1035265704160467500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-12940933115981990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 336
fn c201_l336_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c201_l336_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008947461661755698f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020853844141312436f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018658897095462173f64).to_bits()))));
    result.map(|_| ())
}

// Line 337
fn c202_l337_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c202_l337_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.00000000000000001161813037330394f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018737038135583668f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021768935186877886f64).to_bits()))));
    result.map(|_| ())
}

// Line 338
fn c203_l338_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c203_l338_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021752326768352433f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006631210068072052f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014424424827029184f64).to_bits()))));
    result.map(|_| ())
}

// Line 339
fn c204_l339_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c204_l339_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007149518157441743f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000022770445062365393f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001627977104264113f64).to_bits()))));
    result.map(|_| ())
}

// Line 340
fn c205_l340_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c205_l340_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004817739302150786f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025375023049719763f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012225024583961697f64).to_bits()))));
    result.map(|_| ())
}

// Line 343
fn c206_l343_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c206_l343_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((46576441629501554000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007021344893525714f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000003270292605938992f64).to_bits()))));
    result.map(|_| ())
}

// Line 344
fn c207_l344_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c207_l344_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.012451716278313712f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000001945309177849331f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000002422243795617958f64).to_bits()))));
    result.map(|_| ())
}

// Line 345
fn c208_l345_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c208_l345_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-3.8312314777598586f64).to_bits()), Value::F64((0.0000000000009039887741742674f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000034633902471580017f64).to_bits()))));
    result.map(|_| ())
}

// Line 346
fn c209_l346_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c209_l346_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009843582638849689f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000003375405654777583f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000033226084502443684f64).to_bits()))));
    result.map(|_| ())
}

// Line 347
fn c210_l347_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c210_l347_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((-260544537094514460000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032887528185809035f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000008568665807354412f64).to_bits()))));
    result.map(|_| ())
}

// Line 350
fn c211_l350_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c211_l350_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((0.00000000000000000000002646978f32).to_bits()), Value::F32((0.00000000000000000000002646978f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 351
fn c212_l351_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c212_l351_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((0.000000000000000000000026469783f32).to_bits()), Value::F32((0.000000000000000000000026469783f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 352
fn c213_l352_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c213_l352_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 353
fn c214_l353_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c214_l353_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()))));
    result.map(|_| ())
}

// Line 356
fn c215_l356_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c215_l356_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((18446743000000000000.0f32).to_bits()), Value::F32((18446743000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 357
fn c216_l357_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c216_l357_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((18446744000000000000.0f32).to_bits()), Value::F32((18446744000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 358
fn c217_l358_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c217_l358_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 359
fn c218_l359_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c218_l359_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 362
fn c219_l362_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c219_l362_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((1.0000001f32).to_bits()), Value::F32((1.0000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0000002f32).to_bits()))));
    result.map(|_| ())
}

// Line 363
fn c220_l363_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c220_l363_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((0.99999994f32).to_bits()), Value::F32((0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.9999999f32).to_bits()))));
    result.map(|_| ())
}

// Line 364
fn c221_l364_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c221_l364_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((1.0000000000000002f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0000000000000004f64).to_bits()))));
    result.map(|_| ())
}

// Line 365
fn c222_l365_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c222_l365_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.9999999999999999f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64).to_bits()))));
    result.map(|_| ())
}

// Line 368
fn c223_l368_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c223_l368_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((1.0000001f32).to_bits()), Value::F32((0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 369
fn c224_l369_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c224_l369_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((1.0000002f32).to_bits()), Value::F32((0.9999999f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 370
fn c225_l370_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c225_l370_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 371
fn c226_l371_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c226_l371_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((1.0000000000000004f64).to_bits()), Value::F64((0.9999999999999998f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits()))));
    result.map(|_| ())
}

// Line 375
fn c227_l375_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c227_l375_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.00000011920929f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 376
fn c228_l376_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c228_l376_action_invoke");
    let result = instance.call("f64.mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0000000000000002220446049250313f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()))));
    result.map(|_| ())
}

// Line 379
fn c229_l379_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c229_l379_action_invoke");
    let result = instance.call("f32.mul", &[Value::F32((-16.001465f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000298465f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000004775883f32).to_bits()))));
    result.map(|_| ())
}

// Line 382
fn c230_l382_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c230_l382_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.1234568f32).to_bits()), Value::F32((100.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.011234568f32).to_bits()))));
    result.map(|_| ())
}

// Line 383
fn c231_l383_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c231_l383_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((8391667.0f32).to_bits()), Value::F32((12582905.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.6669102f32).to_bits()))));
    result.map(|_| ())
}

// Line 384
fn c232_l384_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c232_l384_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((65536.0f32).to_bits()), Value::F32((0.000000000007275958f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((9007199000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 385
fn c233_l385_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c233_l385_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.8622957f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005472795f32).to_bits()))));
    result.map(|_| ())
}

// Line 386
fn c234_l386_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c234_l386_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((4.0f32).to_bits()), Value::F32((3.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.3333334f32).to_bits()))));
    result.map(|_| ())
}

// Line 387
fn c235_l387_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c235_l387_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.123456789f64).to_bits()), Value::F64((100.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.01123456789f64).to_bits()))));
    result.map(|_| ())
}

// Line 388
fn c236_l388_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c236_l388_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((8391667.0f64).to_bits()), Value::F64((12582905.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.6669101451532854f64).to_bits()))));
    result.map(|_| ())
}

// Line 389
fn c237_l389_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c237_l389_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((65536.0f64).to_bits()), Value::F64((0.000000000007275957614183426f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((9007199254740992.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 390
fn c238_l390_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c238_l390_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.8622957468032837f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001035936395755283f64).to_bits()))));
    result.map(|_| ())
}

// Line 391
fn c239_l391_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c239_l391_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((4.0f64).to_bits()), Value::F64((3.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.3333333333333333f64).to_bits()))));
    result.map(|_| ())
}

// Line 395
fn c240_l395_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c240_l395_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((4195835.0f32).to_bits()), Value::F32((3145727.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.3338205f32).to_bits()))));
    result.map(|_| ())
}

// Line 396
fn c241_l396_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c241_l396_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((4195835.0f64).to_bits()), Value::F64((3145727.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.333820449136241f64).to_bits()))));
    result.map(|_| ())
}

// Line 399
fn c242_l399_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c242_l399_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.000000000000005029633f32).to_bits()), Value::F32((336324380000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 400
fn c243_l400_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c243_l400_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000008921987f32).to_bits()), Value::F32((354097530000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 401
fn c244_l401_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c244_l401_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-104167.47f32).to_bits()), Value::F32((0.0000000000000000000000015866623f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-65651950000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 402
fn c245_l402_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c245_l402_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-0.000000000000000000000024938657f32).to_bits()), Value::F32((-0.00000000000000000000000000000000000036230088f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((68834107000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 403
fn c246_l403_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c246_l403_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-4142204200000.0f32).to_bits()), Value::F32((0.0000000000000000000000011954948f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3464845000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 404
fn c247_l404_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c247_l404_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((193901163824483840000000000000000000000000000.0f64).to_bits()), Value::F64((25290742357348314000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000007666883046955921f64).to_bits()))));
    result.map(|_| ())
}

// Line 405
fn c248_l405_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c248_l405_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006600332149752304f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003007915153468629f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((219432125342399270000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 406
fn c249_l406_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c249_l406_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-934827517366190300000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((4809309529035847000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019437873809582001f64).to_bits()))));
    result.map(|_| ())
}

// Line 407
fn c250_l407_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c250_l407_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-17598339088417535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((199386072580682850000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-88262629684409150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 408
fn c251_l408_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c251_l408_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-4566268877844991000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((31282495822334530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-145968816036246260000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 411
fn c252_l411_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c252_l411_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-1039406400000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000012965966f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 412
fn c253_l412_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c253_l412_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.000000000000026831563f32).to_bits()), Value::F32((31241038000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000008588563f32).to_bits()))));
    result.map(|_| ())
}

// Line 413
fn c254_l413_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c254_l413_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.2734247f32).to_bits()), Value::F32((-692783700000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000018381274f32).to_bits()))));
    result.map(|_| ())
}

// Line 414
fn c255_l414_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c255_l414_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.00000000000000068988827f32).to_bits()), Value::F32((0.000000000000000000000000000000000000003762676f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((183350460000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 415
fn c256_l415_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c256_l415_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1819916200000000000000000000.0f32).to_bits()), Value::F32((205067030000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8.874739f32).to_bits()))));
    result.map(|_| ())
}

// Line 416
fn c257_l416_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c257_l416_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021137715924428077f64).to_bits()), Value::F64((-16733261612910253000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 417
fn c258_l417_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c258_l417_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008116644948016275f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006517571349002277f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012453480772801648f64).to_bits()))));
    result.map(|_| ())
}

// Line 418
fn c259_l418_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c259_l418_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009335476912259029f64).to_bits()), Value::F64((-39099281466396.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023876338802497726f64).to_bits()))));
    result.map(|_| ())
}

// Line 419
fn c260_l419_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c260_l419_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-1686856985488590200000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013535993861076857f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-12462010568276012000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 420
fn c261_l420_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c261_l420_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-173388773324941200000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-70026160475217470.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((2476057121342590000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 423
fn c262_l423_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c262_l423_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((93506190.0f32).to_bits()), Value::F32((0.0000000000000000000000000000000000028760885f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 424
fn c263_l424_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c263_l424_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-200575400000000000000000.0f32).to_bits()), Value::F32((246697220.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-813042800000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 425
fn c264_l425_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c264_l425_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((384712200000.0f32).to_bits()), Value::F32((-107037850000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000359417f32).to_bits()))));
    result.map(|_| ())
}

// Line 426
fn c265_l426_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c265_l426_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-4156665000000000000000000000000000.0f32).to_bits()), Value::F32((-901.4192f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((4611245300000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 427
fn c266_l427_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c266_l427_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-6702387000000000000000000000.0f32).to_bits()), Value::F32((-14000.255f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((478733200000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 428
fn c267_l428_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c267_l428_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010085269598907525f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018780374032850215f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-53701111496.85621f64).to_bits()))));
    result.map(|_| ())
}

// Line 429
fn c268_l429_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c268_l429_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-32571664562951100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005885738519211168f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 430
fn c269_l430_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c269_l430_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031640946861233317f64).to_bits()), Value::F64((0.000000000000000000045854510556516254f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006900291046010721f64).to_bits()))));
    result.map(|_| ())
}

// Line 431
fn c270_l431_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c270_l431_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-526842242946656600000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014816907071451201f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((355568298030134360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 432
fn c271_l432_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c271_l432_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((4039956270017490000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-47097881971884274000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000857778757955442f64).to_bits()))));
    result.map(|_| ())
}

// Line 435
fn c272_l435_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c272_l435_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-203959560468347600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-74740887394612260000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((2728888665604071000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 436
fn c273_l436_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c273_l436_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-304261712294687660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-2655679232658824300000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((114570204320220420000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 437
fn c274_l437_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c274_l437_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((49235240512480730000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-366340828310036700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013439736089369927f64).to_bits()))));
    result.map(|_| ())
}

// Line 438
fn c275_l438_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c275_l438_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((289260843556341600000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((517194875837335500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000005592879146144478f64).to_bits()))));
    result.map(|_| ())
}

// Line 439
fn c276_l439_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c276_l439_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-421542582344268600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1428505854670649100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-295093352936560340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 442
fn c277_l442_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c277_l442_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.8622957433108482f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010359363938125513f64).to_bits()))));
    result.map(|_| ())
}

// Line 443
fn c278_l443_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c278_l443_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008566632480779937f64).to_bits()), Value::F64((5381.2699796556235f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001591935084685746f64).to_bits()))));
    result.map(|_| ())
}

// Line 444
fn c279_l444_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c279_l444_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-0.00000000000000000000000000000000000000000008196220919495565f64).to_bits()), Value::F64((-10406557086484777000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007876015911295176f64).to_bits()))));
    result.map(|_| ())
}

// Line 445
fn c280_l445_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c280_l445_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007052801866447111f64).to_bits()), Value::F64((-13767429405781133000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005122816800851397f64).to_bits()))));
    result.map(|_| ())
}

// Line 446
fn c281_l446_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c281_l446_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022655621734165475f64).to_bits()), Value::F64((133219932963494700000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017006180103974106f64).to_bits()))));
    result.map(|_| ())
}

// Line 447
fn c282_l447_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c282_l447_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004196304106554003f64).to_bits()), Value::F64((-9789327.297653636f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042866113053139f64).to_bits()))));
    result.map(|_| ())
}

// Line 450
fn c283_l450_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c283_l450_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1038860800000000000000000000.0f32).to_bits()), Value::F32((6211079500000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((167259300000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 451
fn c284_l451_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c284_l451_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1869033000000000000000000000.0f32).to_bits()), Value::F32((-112355730000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00001663496f32).to_bits()))));
    result.map(|_| ())
}

// Line 452
fn c285_l452_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c285_l452_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((3290747200000000000000000.0f32).to_bits()), Value::F32((0.9064788f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3630252700000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 453
fn c286_l453_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c286_l453_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-908946.56f32).to_bits()), Value::F32((-17034289000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000053359818f32).to_bits()))));
    result.map(|_| ())
}

// Line 454
fn c287_l454_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c287_l454_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((-0.00000000000024092477f32).to_bits()), Value::F32((-89840810000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000026816852f32).to_bits()))));
    result.map(|_| ())
}

// Line 455
fn c288_l455_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c288_l455_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((3910973045785834000.0f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008392730733897136f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-46599529638070336000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 456
fn c289_l456_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c289_l456_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.0000000000000000000000000000000000000008379351966732404f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021077277802048832f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-3975538039318286000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 457
fn c290_l457_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c290_l457_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((4561142017854715000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1500578067736849100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((3039589952.6465592f64).to_bits()))));
    result.map(|_| ())
}

// Line 458
fn c291_l458_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c291_l458_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-6236072401827852000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((83170632504609900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007497925907299316f64).to_bits()))));
    result.map(|_| ())
}

// Line 459
fn c292_l459_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c292_l459_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009757271330468098f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035613812243480865f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000002739743575824061f64).to_bits()))));
    result.map(|_| ())
}

// Line 462
fn c293_l462_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c293_l462_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.00000000000000001046256872449641f64).to_bits()), Value::F64((1.8150892711657447f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000005764217160391678f64).to_bits()))));
    result.map(|_| ())
}

// Line 463
fn c294_l463_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c294_l463_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.00000000000000000000000000000022038268106596436f64).to_bits()), Value::F64((-0.0000000000002859803943943555f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000007706216418530616f64).to_bits()))));
    result.map(|_| ())
}

// Line 464
fn c295_l464_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c295_l464_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.0000000000007596539988437179f64).to_bits()), Value::F64((0.00000000000000000000000000000000021055358831337124f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((3607889112357986600000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 465
fn c296_l465_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c296_l465_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1120696114500866900000000000.0f64).to_bits()), Value::F64((159713233802866500000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.007016927074960728f64).to_bits()))));
    result.map(|_| ())
}

// Line 466
fn c297_l466_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c297_l466_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.0006342142502301953f64).to_bits()), Value::F64((-6391950865520085.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000009922076429769178f64).to_bits()))));
    result.map(|_| ())
}

// Line 469
fn c298_l469_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c298_l469_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 470
fn c299_l470_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c299_l470_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.9999999f32).to_bits()))));
    result.map(|_| ())
}

// Line 471
fn c300_l471_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c300_l471_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits()))));
    result.map(|_| ())
}

// Line 472
fn c301_l472_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c301_l472_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64).to_bits()))));
    result.map(|_| ())
}

// Line 475
fn c302_l475_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c302_l475_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.00000023841856f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 476
fn c303_l476_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c303_l476_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.00000023841858f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 477
fn c304_l477_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c304_l477_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.00000000000000044408920985006257f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 478
fn c305_l478_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c305_l478_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.0000000000000004440892098500626f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()))));
    result.map(|_| ())
}

// Line 481
fn c306_l481_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c306_l481_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000002938736f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 482
fn c307_l482_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c307_l482_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000002938737f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282200000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 483
fn c308_l483_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c308_l483_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 484
fn c309_l484_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c309_l484_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000556268464626801f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((179769313486231430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 487
fn c310_l487_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c310_l487_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((85070600000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 488
fn c311_l488_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c311_l488_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((85070590000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 489
fn c312_l489_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c312_l489_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((44942328371557910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits()))));
    result.map(|_| ())
}

// Line 490
fn c313_l490_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c313_l490_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()))));
    result.map(|_| ())
}

// Line 500
fn c314_l500_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c314_l500_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((3.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.33333334f32).to_bits()))));
    result.map(|_| ())
}

// Line 501
fn c315_l501_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c315_l501_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((3.0f32).to_bits()), Value::F32((9.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.33333334f32).to_bits()))));
    result.map(|_| ())
}

// Line 502
fn c316_l502_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c316_l502_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((9.0f32).to_bits()), Value::F32((27.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.33333334f32).to_bits()))));
    result.map(|_| ())
}

// Line 503
fn c317_l503_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c317_l503_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((3.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.3333333333333333f64).to_bits()))));
    result.map(|_| ())
}

// Line 504
fn c318_l504_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c318_l504_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((3.0f64).to_bits()), Value::F64((9.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.3333333333333333f64).to_bits()))));
    result.map(|_| ())
}

// Line 505
fn c319_l505_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c319_l505_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((9.0f64).to_bits()), Value::F64((27.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.3333333333333333f64).to_bits()))));
    result.map(|_| ())
}

// Line 508
fn c320_l508_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c320_l508_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.0000001f32).to_bits()), Value::F32((0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0000002f32).to_bits()))));
    result.map(|_| ())
}

// Line 509
fn c321_l509_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c321_l509_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((0.99999994f32).to_bits()), Value::F32((1.0000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 510
fn c322_l510_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c322_l510_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 511
fn c323_l511_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c323_l511_action_invoke");
    let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.9999999f32).to_bits()))));
    result.map(|_| ())
}

// Line 512
fn c324_l512_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c324_l512_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0000000000000004f64).to_bits()))));
    result.map(|_| ())
}

// Line 513
fn c325_l513_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c325_l513_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((0.9999999999999999f64).to_bits()), Value::F64((1.0000000000000002f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.9999999999999997f64).to_bits()))));
    result.map(|_| ())
}

// Line 514
fn c326_l514_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c326_l514_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits()))));
    result.map(|_| ())
}

// Line 515
fn c327_l515_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c327_l515_action_invoke");
    let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0000000000000002f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64).to_bits()))));
    result.map(|_| ())
}

// Line 519
fn c328_l519_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c328_l519_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((171.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((13.076696f32).to_bits()))));
    result.map(|_| ())
}

// Line 520
fn c329_l520_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c329_l520_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.000000160795f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00040099252f32).to_bits()))));
    result.map(|_| ())
}

// Line 521
fn c330_l521_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c330_l521_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((171.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((13.076696830622021f64).to_bits()))));
    result.map(|_| ())
}

// Line 522
fn c331_l522_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c331_l522_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.000000160795f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00040099251863345283f64).to_bits()))));
    result.map(|_| ())
}

// Line 525
fn c332_l525_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c332_l525_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000004316357580352844f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000020775845543209175f64).to_bits()))));
    result.map(|_| ())
}

// Line 526
fn c333_l526_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c333_l526_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((676253300479648500000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((822346216918183800000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 527
fn c334_l527_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c334_l527_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((17485296624861996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4181542373916829400000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 528
fn c335_l528_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c335_l528_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.000000000009593720960603523f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000030973732355987585f64).to_bits()))));
    result.map(|_| ())
}

// Line 529
fn c336_l529_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c336_l529_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006348452898717835f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000002519613640762773f64).to_bits()))));
    result.map(|_| ())
}

// Line 533
fn c337_l533_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c337_l533_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.9999999999999999f64).to_bits()))));
    result.map(|_| ())
}

// Line 536
fn c338_l536_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c338_l536_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.12963942f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.36005473f32).to_bits()))));
    result.map(|_| ())
}

// Line 537
fn c339_l537_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c339_l537_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((2345875800000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1531625200000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 538
fn c340_l538_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c340_l538_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.078786574f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.28068945f32).to_bits()))));
    result.map(|_| ())
}

// Line 539
fn c341_l539_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c341_l539_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000051371026f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000022665177f32).to_bits()))));
    result.map(|_| ())
}

// Line 540
fn c342_l540_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c342_l540_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.00090167153f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.030027846f32).to_bits()))));
    result.map(|_| ())
}

// Line 541
fn c343_l541_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c343_l541_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009591922760825561f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009793836204892116f64).to_bits()))));
    result.map(|_| ())
}

// Line 542
fn c344_l542_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c344_l542_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((935787535216400500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((30590644570136150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 543
fn c345_l543_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c345_l543_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((147706699783365580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((12153464517715332000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 544
fn c346_l544_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c346_l544_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((48800457180027890000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((6985732401117859.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 545
fn c347_l545_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c347_l545_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((7618977687174540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((2760249569726357000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 548
fn c348_l548_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c348_l548_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((154481010.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((12429.039f32).to_bits()))));
    result.map(|_| ())
}

// Line 549
fn c349_l549_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c349_l549_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000000000000000010471305f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000001023294f32).to_bits()))));
    result.map(|_| ())
}

// Line 550
fn c350_l550_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c350_l550_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.00003790637f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.006156815f32).to_bits()))));
    result.map(|_| ())
}

// Line 551
fn c351_l551_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c351_l551_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000000000000000000089607535f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000009466126f32).to_bits()))));
    result.map(|_| ())
}

// Line 552
fn c352_l552_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c352_l552_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.0000000000000000000000000000000000001687712f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000041081773f32).to_bits()))));
    result.map(|_| ())
}

// Line 553
fn c353_l553_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c353_l553_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((316996264378909500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((563024212959717700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 554
fn c354_l554_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c354_l554_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040573669271847993f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020142906759414837f64).to_bits()))));
    result.map(|_| ())
}

// Line 555
fn c355_l555_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c355_l555_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.0000000015299861660588838f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00003911503759500793f64).to_bits()))));
    result.map(|_| ())
}

// Line 556
fn c356_l556_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c356_l556_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000002822766928951239f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000005312971794533864f64).to_bits()))));
    result.map(|_| ())
}

// Line 557
fn c357_l557_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c357_l557_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((14375957727045067000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((119899782014168260000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 560
fn c358_l560_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c358_l560_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((464023420000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((681192700000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 561
fn c359_l561_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c359_l561_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((47536.133f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((218.02783f32).to_bits()))));
    result.map(|_| ())
}

// Line 562
fn c360_l562_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c360_l562_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.812613f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.9014505f32).to_bits()))));
    result.map(|_| ())
}

// Line 563
fn c361_l563_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c361_l563_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.000000000000000000000000009549605f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000009772208f32).to_bits()))));
    result.map(|_| ())
}

// Line 564
fn c362_l564_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c362_l564_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.000000000000000000000000000068856485f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000008297981f32).to_bits()))));
    result.map(|_| ())
}

// Line 565
fn c363_l565_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c363_l565_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((2349768917495332200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1532895599020146000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 566
fn c364_l566_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c364_l566_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029262574743429683f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000005409489323718985f64).to_bits()))));
    result.map(|_| ())
}

// Line 567
fn c365_l567_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c365_l567_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((377335087484490800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((19425114864126050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 568
fn c366_l568_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c366_l568_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000035498432023945234f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000018841027579180822f64).to_bits()))));
    result.map(|_| ())
}

// Line 569
fn c367_l569_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c367_l569_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013747419336166767f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000011724938949165905f64).to_bits()))));
    result.map(|_| ())
}

// Line 572
fn c368_l572_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c368_l572_assert_return_canonical_nan");
    let result = instance.call("f64.sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015535152663257847f64).to_bits())]).unwrap().expect("Missing result in c368_l572_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 573
fn c369_l573_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c369_l573_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((18763296348029700000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4331662076851067.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 574
fn c370_l574_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c370_l574_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000274405777036165f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000523837548325972f64).to_bits()))));
    result.map(|_| ())
}

// Line 575
fn c371_l575_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c371_l575_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000015613859952920445f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000039514377070783294f64).to_bits()))));
    result.map(|_| ())
}

// Line 576
fn c372_l576_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c372_l576_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((619303768945071200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((24885814612848646000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 579
fn c373_l579_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c373_l579_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((1.0000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 580
fn c374_l580_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c374_l580_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((1.0000002f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 581
fn c375_l581_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c375_l581_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((1.0000000000000002f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 582
fn c376_l582_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c376_l582_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((1.0000000000000004f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits()))));
    result.map(|_| ())
}

// Line 585
fn c377_l585_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c377_l585_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.9999999f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.99999994f32).to_bits()))));
    result.map(|_| ())
}

// Line 586
fn c378_l586_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c378_l586_action_invoke");
    let result = instance.call("f32.sqrt", &[Value::F32((0.9999998f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.9999999f32).to_bits()))));
    result.map(|_| ())
}

// Line 587
fn c379_l587_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c379_l587_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.9999999999999998f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.9999999999999999f64).to_bits()))));
    result.map(|_| ())
}

// Line 588
fn c380_l588_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c380_l588_action_invoke");
    let result = instance.call("f64.sqrt", &[Value::F64((0.9999999999999997f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64).to_bits()))));
    result.map(|_| ())
}

// Line 592
fn c381_l592_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c381_l592_action_invoke");
    let result = instance.call("f32.abs", &[Value::F32(f32::from_bits(2139156962) as u32)]);
    let expected = f32::from_bits(2139156962);
                                if let Value::F32(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f32).is_nan());
            assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 593
fn c382_l593_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c382_l593_action_invoke");
    let result = instance.call("f32.abs", &[Value::F32(f32::from_bits(4286640610) as u32)]);
    let expected = f32::from_bits(2139156962);
                                if let Value::F32(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f32).is_nan());
            assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 594
fn c383_l594_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c383_l594_action_invoke");
    let result = instance.call("f64.abs", &[Value::F64(f64::from_bits(9218868441285556843) as u64)]);
    let expected = f64::from_bits(9218868441285556843);
                                if let Value::F64(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f64).is_nan());
            assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 595
fn c384_l595_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c384_l595_action_invoke");
    let result = instance.call("f64.abs", &[Value::F64(f64::from_bits(18442240478140332651) as u64)]);
    let expected = f64::from_bits(9218868441285556843);
                                if let Value::F64(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f64).is_nan());
            assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 597
fn c385_l597_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c385_l597_action_invoke");
    let result = instance.call("f32.neg", &[Value::F32(f32::from_bits(2139156962) as u32)]);
    let expected = f32::from_bits(4286640610);
                                if let Value::F32(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f32).is_nan());
            assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 598
fn c386_l598_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c386_l598_action_invoke");
    let result = instance.call("f32.neg", &[Value::F32(f32::from_bits(4286640610) as u32)]);
    let expected = f32::from_bits(2139156962);
                                if let Value::F32(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f32).is_nan());
            assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 599
fn c387_l599_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c387_l599_action_invoke");
    let result = instance.call("f64.neg", &[Value::F64(f64::from_bits(9218868441285556843) as u64)]);
    let expected = f64::from_bits(18442240478140332651);
                                if let Value::F64(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f64).is_nan());
            assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 600
fn c388_l600_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c388_l600_action_invoke");
    let result = instance.call("f64.neg", &[Value::F64(f64::from_bits(18442240478140332651) as u64)]);
    let expected = f64::from_bits(9218868441285556843);
                                if let Value::F64(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f64).is_nan());
            assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 602
fn c389_l602_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c389_l602_action_invoke");
    let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(2139156962) as u32), Value::F32(f32::from_bits(2143289344) as u32)]);
    let expected = f32::from_bits(2139156962);
                                if let Value::F32(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f32).is_nan());
            assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 603
fn c390_l603_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c390_l603_action_invoke");
    let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(2139156962) as u32), Value::F32(f32::from_bits(4290772992) as u32)]);
    let expected = f32::from_bits(4286640610);
                                if let Value::F32(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f32).is_nan());
            assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 604
fn c391_l604_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c391_l604_action_invoke");
    let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(4286640610) as u32), Value::F32(f32::from_bits(2143289344) as u32)]);
    let expected = f32::from_bits(2139156962);
                                if let Value::F32(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f32).is_nan());
            assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 605
fn c392_l605_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c392_l605_action_invoke");
    let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(4286640610) as u32), Value::F32(f32::from_bits(4290772992) as u32)]);
    let expected = f32::from_bits(4286640610);
                                if let Value::F32(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f32).is_nan());
            assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 606
fn c393_l606_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c393_l606_action_invoke");
    let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(9218868441285556843) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]);
    let expected = f64::from_bits(9218868441285556843);
                                if let Value::F64(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f64).is_nan());
            assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 607
fn c394_l607_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c394_l607_action_invoke");
    let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(9218868441285556843) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]);
    let expected = f64::from_bits(18442240478140332651);
                                if let Value::F64(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f64).is_nan());
            assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 608
fn c395_l608_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c395_l608_action_invoke");
    let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(18442240478140332651) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]);
    let expected = f64::from_bits(9218868441285556843);
                                if let Value::F64(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f64).is_nan());
            assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 609
fn c396_l609_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c396_l609_action_invoke");
    let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(18442240478140332651) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]);
    let expected = f64::from_bits(18442240478140332651);
                                if let Value::F64(result) = result.clone().unwrap().unwrap() {
                                assert!((result as f64).is_nan());
            assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive());
            } else {
              panic!("Unexpected result type {:?}", result);
            }
    result.map(|_| ())
}

// Line 612
fn c397_l612_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c397_l612_action_invoke");
    let result = instance.call("f32.ceil", &[Value::F32((0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 613
fn c398_l613_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c398_l613_action_invoke");
    let result = instance.call("f32.ceil", &[Value::F32((1.0000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 614
fn c399_l614_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c399_l614_action_invoke");
    let result = instance.call("f64.ceil", &[Value::F64((0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 615
fn c400_l615_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c400_l615_action_invoke");
    let result = instance.call("f64.ceil", &[Value::F64((1.0000000000000002f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 618
fn c401_l618_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c401_l618_action_invoke");
    let result = instance.call("f32.ceil", &[Value::F32((8388607.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 619
fn c402_l619_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c402_l619_action_invoke");
    let result = instance.call("f32.ceil", &[Value::F32((-8388607.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-8388607.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 620
fn c403_l620_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c403_l620_action_invoke");
    let result = instance.call("f64.ceil", &[Value::F64((4503599627370495.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 621
fn c404_l621_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c404_l621_action_invoke");
    let result = instance.call("f64.ceil", &[Value::F64((-4503599627370495.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-4503599627370495.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 625
fn c405_l625_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c405_l625_action_invoke");
    let result = instance.call("f32.ceil", &[Value::F32((16777215.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((16777215.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 626
fn c406_l626_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c406_l626_action_invoke");
    let result = instance.call("f32.ceil", &[Value::F32((-16777215.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-16777215.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 627
fn c407_l627_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c407_l627_action_invoke");
    let result = instance.call("f64.ceil", &[Value::F64((9007199254740991.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((9007199254740991.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 628
fn c408_l628_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c408_l628_action_invoke");
    let result = instance.call("f64.ceil", &[Value::F64((-9007199254740991.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-9007199254740991.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 631
fn c409_l631_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c409_l631_action_invoke");
    let result = instance.call("f32.floor", &[Value::F32((-0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 632
fn c410_l632_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c410_l632_action_invoke");
    let result = instance.call("f32.floor", &[Value::F32((-1.0000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 633
fn c411_l633_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c411_l633_action_invoke");
    let result = instance.call("f64.floor", &[Value::F64((-0.9999999999999999f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 634
fn c412_l634_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c412_l634_action_invoke");
    let result = instance.call("f64.floor", &[Value::F64((-1.0000000000000002f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-2.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 637
fn c413_l637_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c413_l637_action_invoke");
    let result = instance.call("f32.floor", &[Value::F32((-8388607.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 638
fn c414_l638_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c414_l638_action_invoke");
    let result = instance.call("f32.floor", &[Value::F32((8388607.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388607.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 639
fn c415_l639_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c415_l639_action_invoke");
    let result = instance.call("f64.floor", &[Value::F64((-4503599627370495.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-4503599627370496.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 640
fn c416_l640_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c416_l640_action_invoke");
    let result = instance.call("f64.floor", &[Value::F64((4503599627370495.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4503599627370495.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 644
fn c417_l644_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c417_l644_action_invoke");
    let result = instance.call("f32.floor", &[Value::F32((88607.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((88607.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 645
fn c418_l645_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c418_l645_action_invoke");
    let result = instance.call("f64.floor", &[Value::F64((88607.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((88607.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 648
fn c419_l648_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c419_l648_action_invoke");
    let result = instance.call("f32.trunc", &[Value::F32((-8388607.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-8388607.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 649
fn c420_l649_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c420_l649_action_invoke");
    let result = instance.call("f32.trunc", &[Value::F32((8388607.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388607.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 650
fn c421_l650_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c421_l650_action_invoke");
    let result = instance.call("f64.trunc", &[Value::F64((-4503599627370495.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-4503599627370495.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 651
fn c422_l651_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c422_l651_action_invoke");
    let result = instance.call("f64.trunc", &[Value::F64((4503599627370495.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4503599627370495.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 656
fn c423_l656_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c423_l656_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((8388609.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388609.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 657
fn c424_l657_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c424_l657_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((8388610.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388610.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 658
fn c425_l658_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c425_l658_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((0.49999997f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 659
fn c426_l659_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c426_l659_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((281474960000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((281474960000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 660
fn c427_l660_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c427_l660_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((4503599627370497.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4503599627370497.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 661
fn c428_l661_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c428_l661_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((4503599627370498.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4503599627370498.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 662
fn c429_l662_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c429_l662_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((0.49999999999999994f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 663
fn c430_l663_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c430_l663_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((81129638414606670000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((81129638414606670000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 667
fn c431_l667_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c431_l667_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((4.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((4.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 668
fn c432_l668_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c432_l668_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((-4.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-4.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 669
fn c433_l669_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c433_l669_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((-3.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-4.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 670
fn c434_l670_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c434_l670_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((4.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 671
fn c435_l671_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c435_l671_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((-4.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-4.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 672
fn c436_l672_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c436_l672_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((-3.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-4.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 675
fn c437_l675_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c437_l675_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((-8388607.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 676
fn c438_l676_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c438_l676_action_invoke");
    let result = instance.call("f32.nearest", &[Value::F32((8388607.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 677
fn c439_l677_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c439_l677_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((-4503599627370495.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((-4503599627370496.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 678
fn c440_l678_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c440_l678_action_invoke");
    let result = instance.call("f64.nearest", &[Value::F64((4503599627370495.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64).to_bits()))));
    result.map(|_| ())
}

#[test]
fn test_module_1() {
    let mut instance = create_module_1();
    // We group the calls together
    start_module_1(&mut instance);
    c1_l50_action_invoke(&mut instance);
    c2_l51_action_invoke(&mut instance);
    c3_l55_action_invoke(&mut instance);
    c4_l56_action_invoke(&mut instance);
    c5_l57_action_invoke(&mut instance);
    c6_l58_action_invoke(&mut instance);
    c7_l61_action_invoke(&mut instance);
    c8_l62_action_invoke(&mut instance);
    c9_l67_action_invoke(&mut instance);
    c10_l68_action_invoke(&mut instance);
    c11_l72_action_invoke(&mut instance);
    c12_l75_action_invoke(&mut instance);
    c13_l78_action_invoke(&mut instance);
    c14_l81_action_invoke(&mut instance);
    c15_l82_action_invoke(&mut instance);
    c16_l83_action_invoke(&mut instance);
    c17_l84_action_invoke(&mut instance);
    c18_l87_action_invoke(&mut instance);
    c19_l88_action_invoke(&mut instance);
    c20_l89_action_invoke(&mut instance);
    c21_l90_action_invoke(&mut instance);
    c22_l91_action_invoke(&mut instance);
    c23_l92_action_invoke(&mut instance);
    c24_l93_action_invoke(&mut instance);
    c25_l94_action_invoke(&mut instance);
    c26_l95_action_invoke(&mut instance);
    c27_l96_action_invoke(&mut instance);
    c28_l99_action_invoke(&mut instance);
    c29_l100_action_invoke(&mut instance);
    c30_l101_action_invoke(&mut instance);
    c31_l102_action_invoke(&mut instance);
    c32_l103_action_invoke(&mut instance);
    c33_l104_action_invoke(&mut instance);
    c34_l105_action_invoke(&mut instance);
    c35_l106_action_invoke(&mut instance);
    c36_l107_action_invoke(&mut instance);
    c37_l108_action_invoke(&mut instance);
    c38_l111_action_invoke(&mut instance);
    c39_l112_action_invoke(&mut instance);
    c40_l113_action_invoke(&mut instance);
    c41_l114_action_invoke(&mut instance);
    c42_l115_action_invoke(&mut instance);
    c43_l116_action_invoke(&mut instance);
    c44_l117_action_invoke(&mut instance);
    c45_l118_action_invoke(&mut instance);
    c46_l119_action_invoke(&mut instance);
    c47_l120_action_invoke(&mut instance);
    c48_l123_action_invoke(&mut instance);
    c49_l124_action_invoke(&mut instance);
    c50_l125_action_invoke(&mut instance);
    c51_l126_action_invoke(&mut instance);
    c52_l127_action_invoke(&mut instance);
    c53_l130_action_invoke(&mut instance);
    c54_l131_action_invoke(&mut instance);
    c55_l132_action_invoke(&mut instance);
    c56_l133_action_invoke(&mut instance);
    c57_l134_action_invoke(&mut instance);
    c58_l137_action_invoke(&mut instance);
    c59_l138_action_invoke(&mut instance);
    c60_l139_action_invoke(&mut instance);
    c61_l140_action_invoke(&mut instance);
    c62_l141_action_invoke(&mut instance);
    c63_l142_action_invoke(&mut instance);
    c64_l143_action_invoke(&mut instance);
    c65_l144_action_invoke(&mut instance);
    c66_l145_action_invoke(&mut instance);
    c67_l146_action_invoke(&mut instance);
    c68_l149_action_invoke(&mut instance);
    c69_l150_action_invoke(&mut instance);
    c70_l151_action_invoke(&mut instance);
    c71_l152_action_invoke(&mut instance);
    c72_l153_action_invoke(&mut instance);
    c73_l154_action_invoke(&mut instance);
    c74_l155_action_invoke(&mut instance);
    c75_l156_action_invoke(&mut instance);
    c76_l157_action_invoke(&mut instance);
    c77_l158_action_invoke(&mut instance);
    c78_l162_action_invoke(&mut instance);
    c79_l163_action_invoke(&mut instance);
    c80_l166_action_invoke(&mut instance);
    c81_l167_action_invoke(&mut instance);
    c82_l170_action_invoke(&mut instance);
    c83_l171_action_invoke(&mut instance);
    c84_l172_action_invoke(&mut instance);
    c85_l173_action_invoke(&mut instance);
    c86_l177_action_invoke(&mut instance);
    c87_l178_action_invoke(&mut instance);
    c88_l182_action_invoke(&mut instance);
    c89_l183_action_invoke(&mut instance);
    c90_l184_action_invoke(&mut instance);
    c91_l185_action_invoke(&mut instance);
    c92_l188_action_invoke(&mut instance);
    c93_l189_action_invoke(&mut instance);
    c94_l190_action_invoke(&mut instance);
    c95_l191_action_invoke(&mut instance);
    c96_l192_action_invoke(&mut instance);
    c97_l193_action_invoke(&mut instance);
    c98_l194_action_invoke(&mut instance);
    c99_l195_action_invoke(&mut instance);
    c100_l196_action_invoke(&mut instance);
    c101_l197_action_invoke(&mut instance);
    c102_l200_action_invoke(&mut instance);
    c103_l201_action_invoke(&mut instance);
    c104_l202_action_invoke(&mut instance);
    c105_l203_action_invoke(&mut instance);
    c106_l204_action_invoke(&mut instance);
    c107_l205_action_invoke(&mut instance);
    c108_l206_action_invoke(&mut instance);
    c109_l207_action_invoke(&mut instance);
    c110_l208_action_invoke(&mut instance);
    c111_l209_action_invoke(&mut instance);
    c112_l212_action_invoke(&mut instance);
    c113_l213_action_invoke(&mut instance);
    c114_l214_action_invoke(&mut instance);
    c115_l215_action_invoke(&mut instance);
    c116_l216_action_invoke(&mut instance);
    c117_l217_action_invoke(&mut instance);
    c118_l218_action_invoke(&mut instance);
    c119_l219_action_invoke(&mut instance);
    c120_l220_action_invoke(&mut instance);
    c121_l221_action_invoke(&mut instance);
    c122_l224_action_invoke(&mut instance);
    c123_l225_action_invoke(&mut instance);
    c124_l226_action_invoke(&mut instance);
    c125_l227_action_invoke(&mut instance);
    c126_l228_action_invoke(&mut instance);
    c127_l231_action_invoke(&mut instance);
    c128_l232_action_invoke(&mut instance);
    c129_l233_action_invoke(&mut instance);
    c130_l234_action_invoke(&mut instance);
    c131_l235_action_invoke(&mut instance);
    c132_l239_action_invoke(&mut instance);
    c133_l240_action_invoke(&mut instance);
    c134_l243_action_invoke(&mut instance);
    c135_l244_action_invoke(&mut instance);
    c136_l245_action_invoke(&mut instance);
    c137_l246_action_invoke(&mut instance);
    c138_l247_action_invoke(&mut instance);
    c139_l248_action_invoke(&mut instance);
    c140_l249_action_invoke(&mut instance);
    c141_l250_action_invoke(&mut instance);
    c142_l251_action_invoke(&mut instance);
    c143_l252_action_invoke(&mut instance);
    c144_l255_action_invoke(&mut instance);
    c145_l256_action_invoke(&mut instance);
    c146_l259_action_invoke(&mut instance);
    c147_l260_action_invoke(&mut instance);
    c148_l261_action_invoke(&mut instance);
    c149_l262_action_invoke(&mut instance);
    c150_l263_action_invoke(&mut instance);
    c151_l264_action_invoke(&mut instance);
    c152_l268_action_invoke(&mut instance);
    c153_l269_action_invoke(&mut instance);
    c154_l270_action_invoke(&mut instance);
    c155_l271_action_invoke(&mut instance);
    c156_l274_action_invoke(&mut instance);
    c157_l275_action_invoke(&mut instance);
    c158_l276_action_invoke(&mut instance);
    c159_l277_action_invoke(&mut instance);
    c160_l278_action_invoke(&mut instance);
    c161_l279_action_invoke(&mut instance);
    c162_l284_action_invoke(&mut instance);
    c163_l285_action_invoke(&mut instance);
    c164_l289_action_invoke(&mut instance);
    c165_l290_action_invoke(&mut instance);
    c166_l293_action_invoke(&mut instance);
    c167_l294_action_invoke(&mut instance);
    c168_l295_action_invoke(&mut instance);
    c169_l296_action_invoke(&mut instance);
    c170_l297_action_invoke(&mut instance);
    c171_l298_action_invoke(&mut instance);
    c172_l299_action_invoke(&mut instance);
    c173_l300_action_invoke(&mut instance);
    c174_l301_action_invoke(&mut instance);
    c175_l302_action_invoke(&mut instance);
    c176_l305_action_invoke(&mut instance);
    c177_l306_action_invoke(&mut instance);
    c178_l307_action_invoke(&mut instance);
    c179_l308_action_invoke(&mut instance);
    c180_l309_action_invoke(&mut instance);
    c181_l310_action_invoke(&mut instance);
    c182_l311_action_invoke(&mut instance);
    c183_l312_action_invoke(&mut instance);
    c184_l313_action_invoke(&mut instance);
    c185_l314_action_invoke(&mut instance);
    c186_l317_action_invoke(&mut instance);
    c187_l318_action_invoke(&mut instance);
    c188_l319_action_invoke(&mut instance);
    c189_l320_action_invoke(&mut instance);
    c190_l321_action_invoke(&mut instance);
    c191_l322_action_invoke(&mut instance);
    c192_l323_action_invoke(&mut instance);
    c193_l324_action_invoke(&mut instance);
    c194_l325_action_invoke(&mut instance);
    c195_l326_action_invoke(&mut instance);
    c196_l329_action_invoke(&mut instance);
    c197_l330_action_invoke(&mut instance);
    c198_l331_action_invoke(&mut instance);
    c199_l332_action_invoke(&mut instance);
    c200_l333_action_invoke(&mut instance);
    c201_l336_action_invoke(&mut instance);
    c202_l337_action_invoke(&mut instance);
    c203_l338_action_invoke(&mut instance);
    c204_l339_action_invoke(&mut instance);
    c205_l340_action_invoke(&mut instance);
    c206_l343_action_invoke(&mut instance);
    c207_l344_action_invoke(&mut instance);
    c208_l345_action_invoke(&mut instance);
    c209_l346_action_invoke(&mut instance);
    c210_l347_action_invoke(&mut instance);
    c211_l350_action_invoke(&mut instance);
    c212_l351_action_invoke(&mut instance);
    c213_l352_action_invoke(&mut instance);
    c214_l353_action_invoke(&mut instance);
    c215_l356_action_invoke(&mut instance);
    c216_l357_action_invoke(&mut instance);
    c217_l358_action_invoke(&mut instance);
    c218_l359_action_invoke(&mut instance);
    c219_l362_action_invoke(&mut instance);
    c220_l363_action_invoke(&mut instance);
    c221_l364_action_invoke(&mut instance);
    c222_l365_action_invoke(&mut instance);
    c223_l368_action_invoke(&mut instance);
    c224_l369_action_invoke(&mut instance);
    c225_l370_action_invoke(&mut instance);
    c226_l371_action_invoke(&mut instance);
    c227_l375_action_invoke(&mut instance);
    c228_l376_action_invoke(&mut instance);
    c229_l379_action_invoke(&mut instance);
    c230_l382_action_invoke(&mut instance);
    c231_l383_action_invoke(&mut instance);
    c232_l384_action_invoke(&mut instance);
    c233_l385_action_invoke(&mut instance);
    c234_l386_action_invoke(&mut instance);
    c235_l387_action_invoke(&mut instance);
    c236_l388_action_invoke(&mut instance);
    c237_l389_action_invoke(&mut instance);
    c238_l390_action_invoke(&mut instance);
    c239_l391_action_invoke(&mut instance);
    c240_l395_action_invoke(&mut instance);
    c241_l396_action_invoke(&mut instance);
    c242_l399_action_invoke(&mut instance);
    c243_l400_action_invoke(&mut instance);
    c244_l401_action_invoke(&mut instance);
    c245_l402_action_invoke(&mut instance);
    c246_l403_action_invoke(&mut instance);
    c247_l404_action_invoke(&mut instance);
    c248_l405_action_invoke(&mut instance);
    c249_l406_action_invoke(&mut instance);
    c250_l407_action_invoke(&mut instance);
    c251_l408_action_invoke(&mut instance);
    c252_l411_action_invoke(&mut instance);
    c253_l412_action_invoke(&mut instance);
    c254_l413_action_invoke(&mut instance);
    c255_l414_action_invoke(&mut instance);
    c256_l415_action_invoke(&mut instance);
    c257_l416_action_invoke(&mut instance);
    c258_l417_action_invoke(&mut instance);
    c259_l418_action_invoke(&mut instance);
    c260_l419_action_invoke(&mut instance);
    c261_l420_action_invoke(&mut instance);
    c262_l423_action_invoke(&mut instance);
    c263_l424_action_invoke(&mut instance);
    c264_l425_action_invoke(&mut instance);
    c265_l426_action_invoke(&mut instance);
    c266_l427_action_invoke(&mut instance);
    c267_l428_action_invoke(&mut instance);
    c268_l429_action_invoke(&mut instance);
    c269_l430_action_invoke(&mut instance);
    c270_l431_action_invoke(&mut instance);
    c271_l432_action_invoke(&mut instance);
    c272_l435_action_invoke(&mut instance);
    c273_l436_action_invoke(&mut instance);
    c274_l437_action_invoke(&mut instance);
    c275_l438_action_invoke(&mut instance);
    c276_l439_action_invoke(&mut instance);
    c277_l442_action_invoke(&mut instance);
    c278_l443_action_invoke(&mut instance);
    c279_l444_action_invoke(&mut instance);
    c280_l445_action_invoke(&mut instance);
    c281_l446_action_invoke(&mut instance);
    c282_l447_action_invoke(&mut instance);
    c283_l450_action_invoke(&mut instance);
    c284_l451_action_invoke(&mut instance);
    c285_l452_action_invoke(&mut instance);
    c286_l453_action_invoke(&mut instance);
    c287_l454_action_invoke(&mut instance);
    c288_l455_action_invoke(&mut instance);
    c289_l456_action_invoke(&mut instance);
    c290_l457_action_invoke(&mut instance);
    c291_l458_action_invoke(&mut instance);
    c292_l459_action_invoke(&mut instance);
    c293_l462_action_invoke(&mut instance);
    c294_l463_action_invoke(&mut instance);
    c295_l464_action_invoke(&mut instance);
    c296_l465_action_invoke(&mut instance);
    c297_l466_action_invoke(&mut instance);
    c298_l469_action_invoke(&mut instance);
    c299_l470_action_invoke(&mut instance);
    c300_l471_action_invoke(&mut instance);
    c301_l472_action_invoke(&mut instance);
    c302_l475_action_invoke(&mut instance);
    c303_l476_action_invoke(&mut instance);
    c304_l477_action_invoke(&mut instance);
    c305_l478_action_invoke(&mut instance);
    c306_l481_action_invoke(&mut instance);
    c307_l482_action_invoke(&mut instance);
    c308_l483_action_invoke(&mut instance);
    c309_l484_action_invoke(&mut instance);
    c310_l487_action_invoke(&mut instance);
    c311_l488_action_invoke(&mut instance);
    c312_l489_action_invoke(&mut instance);
    c313_l490_action_invoke(&mut instance);
    c314_l500_action_invoke(&mut instance);
    c315_l501_action_invoke(&mut instance);
    c316_l502_action_invoke(&mut instance);
    c317_l503_action_invoke(&mut instance);
    c318_l504_action_invoke(&mut instance);
    c319_l505_action_invoke(&mut instance);
    c320_l508_action_invoke(&mut instance);
    c321_l509_action_invoke(&mut instance);
    c322_l510_action_invoke(&mut instance);
    c323_l511_action_invoke(&mut instance);
    c324_l512_action_invoke(&mut instance);
    c325_l513_action_invoke(&mut instance);
    c326_l514_action_invoke(&mut instance);
    c327_l515_action_invoke(&mut instance);
    c328_l519_action_invoke(&mut instance);
    c329_l520_action_invoke(&mut instance);
    c330_l521_action_invoke(&mut instance);
    c331_l522_action_invoke(&mut instance);
    c332_l525_action_invoke(&mut instance);
    c333_l526_action_invoke(&mut instance);
    c334_l527_action_invoke(&mut instance);
    c335_l528_action_invoke(&mut instance);
    c336_l529_action_invoke(&mut instance);
    c337_l533_action_invoke(&mut instance);
    c338_l536_action_invoke(&mut instance);
    c339_l537_action_invoke(&mut instance);
    c340_l538_action_invoke(&mut instance);
    c341_l539_action_invoke(&mut instance);
    c342_l540_action_invoke(&mut instance);
    c343_l541_action_invoke(&mut instance);
    c344_l542_action_invoke(&mut instance);
    c345_l543_action_invoke(&mut instance);
    c346_l544_action_invoke(&mut instance);
    c347_l545_action_invoke(&mut instance);
    c348_l548_action_invoke(&mut instance);
    c349_l549_action_invoke(&mut instance);
    c350_l550_action_invoke(&mut instance);
    c351_l551_action_invoke(&mut instance);
    c352_l552_action_invoke(&mut instance);
    c353_l553_action_invoke(&mut instance);
    c354_l554_action_invoke(&mut instance);
    c355_l555_action_invoke(&mut instance);
    c356_l556_action_invoke(&mut instance);
    c357_l557_action_invoke(&mut instance);
    c358_l560_action_invoke(&mut instance);
    c359_l561_action_invoke(&mut instance);
    c360_l562_action_invoke(&mut instance);
    c361_l563_action_invoke(&mut instance);
    c362_l564_action_invoke(&mut instance);
    c363_l565_action_invoke(&mut instance);
    c364_l566_action_invoke(&mut instance);
    c365_l567_action_invoke(&mut instance);
    c366_l568_action_invoke(&mut instance);
    c367_l569_action_invoke(&mut instance);
    c368_l572_assert_return_canonical_nan(&mut instance);
    c369_l573_action_invoke(&mut instance);
    c370_l574_action_invoke(&mut instance);
    c371_l575_action_invoke(&mut instance);
    c372_l576_action_invoke(&mut instance);
    c373_l579_action_invoke(&mut instance);
    c374_l580_action_invoke(&mut instance);
    c375_l581_action_invoke(&mut instance);
    c376_l582_action_invoke(&mut instance);
    c377_l585_action_invoke(&mut instance);
    c378_l586_action_invoke(&mut instance);
    c379_l587_action_invoke(&mut instance);
    c380_l588_action_invoke(&mut instance);
    c381_l592_action_invoke(&mut instance);
    c382_l593_action_invoke(&mut instance);
    c383_l594_action_invoke(&mut instance);
    c384_l595_action_invoke(&mut instance);
    c385_l597_action_invoke(&mut instance);
    c386_l598_action_invoke(&mut instance);
    c387_l599_action_invoke(&mut instance);
    c388_l600_action_invoke(&mut instance);
    c389_l602_action_invoke(&mut instance);
    c390_l603_action_invoke(&mut instance);
    c391_l604_action_invoke(&mut instance);
    c392_l605_action_invoke(&mut instance);
    c393_l606_action_invoke(&mut instance);
    c394_l607_action_invoke(&mut instance);
    c395_l608_action_invoke(&mut instance);
    c396_l609_action_invoke(&mut instance);
    c397_l612_action_invoke(&mut instance);
    c398_l613_action_invoke(&mut instance);
    c399_l614_action_invoke(&mut instance);
    c400_l615_action_invoke(&mut instance);
    c401_l618_action_invoke(&mut instance);
    c402_l619_action_invoke(&mut instance);
    c403_l620_action_invoke(&mut instance);
    c404_l621_action_invoke(&mut instance);
    c405_l625_action_invoke(&mut instance);
    c406_l626_action_invoke(&mut instance);
    c407_l627_action_invoke(&mut instance);
    c408_l628_action_invoke(&mut instance);
    c409_l631_action_invoke(&mut instance);
    c410_l632_action_invoke(&mut instance);
    c411_l633_action_invoke(&mut instance);
    c412_l634_action_invoke(&mut instance);
    c413_l637_action_invoke(&mut instance);
    c414_l638_action_invoke(&mut instance);
    c415_l639_action_invoke(&mut instance);
    c416_l640_action_invoke(&mut instance);
    c417_l644_action_invoke(&mut instance);
    c418_l645_action_invoke(&mut instance);
    c419_l648_action_invoke(&mut instance);
    c420_l649_action_invoke(&mut instance);
    c421_l650_action_invoke(&mut instance);
    c422_l651_action_invoke(&mut instance);
    c423_l656_action_invoke(&mut instance);
    c424_l657_action_invoke(&mut instance);
    c425_l658_action_invoke(&mut instance);
    c426_l659_action_invoke(&mut instance);
    c427_l660_action_invoke(&mut instance);
    c428_l661_action_invoke(&mut instance);
    c429_l662_action_invoke(&mut instance);
    c430_l663_action_invoke(&mut instance);
    c431_l667_action_invoke(&mut instance);
    c432_l668_action_invoke(&mut instance);
    c433_l669_action_invoke(&mut instance);
    c434_l670_action_invoke(&mut instance);
    c435_l671_action_invoke(&mut instance);
    c436_l672_action_invoke(&mut instance);
    c437_l675_action_invoke(&mut instance);
    c438_l676_action_invoke(&mut instance);
    c439_l677_action_invoke(&mut instance);
    c440_l678_action_invoke(&mut instance);
}