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

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

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


// Line 1
fn create_module_1() -> Box<Instance> {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i64)))
      (type (;1;) (func (param i64) (result i32)))
      (type (;2;) (func (param f32) (result i32)))
      (type (;3;) (func (param f64) (result i32)))
      (type (;4;) (func (param f32) (result i64)))
      (type (;5;) (func (param f64) (result i64)))
      (type (;6;) (func (param i32) (result f32)))
      (type (;7;) (func (param i64) (result f32)))
      (type (;8;) (func (param i32) (result f64)))
      (type (;9;) (func (param i64) (result f64)))
      (type (;10;) (func (param f32) (result f64)))
      (type (;11;) (func (param f64) (result f32)))
      (func (;0;) (type 0) (param i32) (result i64)
        get_local 0
        i64.extend_s/i32)
      (func (;1;) (type 0) (param i32) (result i64)
        get_local 0
        i64.extend_u/i32)
      (func (;2;) (type 1) (param i64) (result i32)
        get_local 0
        i32.wrap/i64)
      (func (;3;) (type 2) (param f32) (result i32)
        get_local 0
        i32.trunc_s/f32)
      (func (;4;) (type 2) (param f32) (result i32)
        get_local 0
        i32.trunc_u/f32)
      (func (;5;) (type 3) (param f64) (result i32)
        get_local 0
        i32.trunc_s/f64)
      (func (;6;) (type 3) (param f64) (result i32)
        get_local 0
        i32.trunc_u/f64)
      (func (;7;) (type 4) (param f32) (result i64)
        get_local 0
        i64.trunc_s/f32)
      (func (;8;) (type 4) (param f32) (result i64)
        get_local 0
        i64.trunc_u/f32)
      (func (;9;) (type 5) (param f64) (result i64)
        get_local 0
        i64.trunc_s/f64)
      (func (;10;) (type 5) (param f64) (result i64)
        get_local 0
        i64.trunc_u/f64)
      (func (;11;) (type 6) (param i32) (result f32)
        get_local 0
        f32.convert_s/i32)
      (func (;12;) (type 7) (param i64) (result f32)
        get_local 0
        f32.convert_s/i64)
      (func (;13;) (type 8) (param i32) (result f64)
        get_local 0
        f64.convert_s/i32)
      (func (;14;) (type 9) (param i64) (result f64)
        get_local 0
        f64.convert_s/i64)
      (func (;15;) (type 6) (param i32) (result f32)
        get_local 0
        f32.convert_u/i32)
      (func (;16;) (type 7) (param i64) (result f32)
        get_local 0
        f32.convert_u/i64)
      (func (;17;) (type 8) (param i32) (result f64)
        get_local 0
        f64.convert_u/i32)
      (func (;18;) (type 9) (param i64) (result f64)
        get_local 0
        f64.convert_u/i64)
      (func (;19;) (type 10) (param f32) (result f64)
        get_local 0
        f64.promote/f32)
      (func (;20;) (type 11) (param f64) (result f32)
        get_local 0
        f32.demote/f64)
      (func (;21;) (type 6) (param i32) (result f32)
        get_local 0
        f32.reinterpret/i32)
      (func (;22;) (type 9) (param i64) (result f64)
        get_local 0
        f64.reinterpret/i64)
      (func (;23;) (type 2) (param f32) (result i32)
        get_local 0
        i32.reinterpret/f32)
      (func (;24;) (type 5) (param f64) (result i64)
        get_local 0
        i64.reinterpret/f64)
      (export \"i64.extend_s_i32\" (func 0))
      (export \"i64.extend_u_i32\" (func 1))
      (export \"i32.wrap_i64\" (func 2))
      (export \"i32.trunc_s_f32\" (func 3))
      (export \"i32.trunc_u_f32\" (func 4))
      (export \"i32.trunc_s_f64\" (func 5))
      (export \"i32.trunc_u_f64\" (func 6))
      (export \"i64.trunc_s_f32\" (func 7))
      (export \"i64.trunc_u_f32\" (func 8))
      (export \"i64.trunc_s_f64\" (func 9))
      (export \"i64.trunc_u_f64\" (func 10))
      (export \"f32.convert_s_i32\" (func 11))
      (export \"f32.convert_s_i64\" (func 12))
      (export \"f64.convert_s_i32\" (func 13))
      (export \"f64.convert_s_i64\" (func 14))
      (export \"f32.convert_u_i32\" (func 15))
      (export \"f32.convert_u_i64\" (func 16))
      (export \"f64.convert_u_i32\" (func 17))
      (export \"f64.convert_u_i64\" (func 18))
      (export \"f64.promote_f32\" (func 19))
      (export \"f32.demote_f64\" (func 20))
      (export \"f32.reinterpret_i32\" (func 21))
      (export \"f64.reinterpret_i64\" (func 22))
      (export \"i32.reinterpret_f32\" (func 23))
      (export \"i64.reinterpret_f64\" (func 24)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
    module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
}

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

// Line 29
fn c1_l29_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1_l29_action_invoke");
    let result = instance.call("i64.extend_s_i32", &[Value::I32(0 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 30
fn c2_l30_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2_l30_action_invoke");
    let result = instance.call("i64.extend_s_i32", &[Value::I32(10000 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(10000 as i64))));
    result.map(|_| ())
}

// Line 31
fn c3_l31_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c3_l31_action_invoke");
    let result = instance.call("i64.extend_s_i32", &[Value::I32(-10000 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(-10000 as i64))));
    result.map(|_| ())
}

// Line 32
fn c4_l32_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c4_l32_action_invoke");
    let result = instance.call("i64.extend_s_i32", &[Value::I32(-1 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 33
fn c5_l33_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c5_l33_action_invoke");
    let result = instance.call("i64.extend_s_i32", &[Value::I32(2147483647 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(2147483647 as i64))));
    result.map(|_| ())
}

// Line 34
fn c6_l34_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c6_l34_action_invoke");
    let result = instance.call("i64.extend_s_i32", &[Value::I32(-2147483648 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(-2147483648 as i64))));
    result.map(|_| ())
}

// Line 36
fn c7_l36_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c7_l36_action_invoke");
    let result = instance.call("i64.extend_u_i32", &[Value::I32(0 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 37
fn c8_l37_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c8_l37_action_invoke");
    let result = instance.call("i64.extend_u_i32", &[Value::I32(10000 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(10000 as i64))));
    result.map(|_| ())
}

// Line 38
fn c9_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c9_l38_action_invoke");
    let result = instance.call("i64.extend_u_i32", &[Value::I32(-10000 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(4294957296 as i64))));
    result.map(|_| ())
}

// Line 39
fn c10_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c10_l39_action_invoke");
    let result = instance.call("i64.extend_u_i32", &[Value::I32(-1 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(4294967295 as i64))));
    result.map(|_| ())
}

// Line 40
fn c11_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c11_l40_action_invoke");
    let result = instance.call("i64.extend_u_i32", &[Value::I32(2147483647 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(2147483647 as i64))));
    result.map(|_| ())
}

// Line 41
fn c12_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c12_l41_action_invoke");
    let result = instance.call("i64.extend_u_i32", &[Value::I32(-2147483648 as i32)]);
    assert_eq!(result, Ok(Some(Value::I64(2147483648 as i64))));
    result.map(|_| ())
}

// Line 43
fn c13_l43_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c13_l43_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(-1 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 44
fn c14_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c14_l44_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(-100000 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(-100000 as i32))));
    result.map(|_| ())
}

// Line 45
fn c15_l45_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c15_l45_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(2147483648 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32))));
    result.map(|_| ())
}

// Line 46
fn c16_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c16_l46_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(-2147483649 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32))));
    result.map(|_| ())
}

// Line 47
fn c17_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c17_l47_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(-4294967296 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 48
fn c18_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c18_l48_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(-4294967297 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 49
fn c19_l49_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c19_l49_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(-4294967295 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 50
fn c20_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c20_l50_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(0 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 51
fn c21_l51_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c21_l51_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(1311768467463790320 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(-1698898192 as i32))));
    result.map(|_| ())
}

// Line 52
fn c22_l52_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c22_l52_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(4294967295 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 53
fn c23_l53_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c23_l53_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(4294967296 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 54
fn c24_l54_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c24_l54_action_invoke");
    let result = instance.call("i32.wrap_i64", &[Value::I64(4294967297 as i64)]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 56
fn c25_l56_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c25_l56_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 57
fn c26_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c26_l57_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 58
fn c27_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c27_l58_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 59
fn c28_l59_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c28_l59_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 60
fn c29_l60_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c29_l60_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 61
fn c30_l61_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c30_l61_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((1.1f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 62
fn c31_l62_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c31_l62_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((1.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 63
fn c32_l63_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c32_l63_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 64
fn c33_l64_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c33_l64_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-1.1f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 65
fn c34_l65_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c34_l65_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-1.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 66
fn c35_l66_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c35_l66_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-1.9f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 67
fn c36_l67_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c36_l67_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-2.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-2 as i32))));
    result.map(|_| ())
}

// Line 68
fn c37_l68_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c37_l68_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((2147483500.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(2147483520 as i32))));
    result.map(|_| ())
}

// Line 69
fn c38_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c38_l69_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-2147483600.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32))));
    result.map(|_| ())
}

// Line 70
fn c39_l70_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c39_l70_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((2147483600.0f32).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c39_l70_assert_trap() {
    let mut instance = create_module_1();
    let result = c39_l70_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 71
fn c40_l71_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c40_l71_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32((-2147484000.0f32).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c40_l71_assert_trap() {
    let mut instance = create_module_1();
    let result = c40_l71_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 72
fn c41_l72_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c41_l72_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c41_l72_assert_trap() {
    let mut instance = create_module_1();
    let result = c41_l72_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 73
fn c42_l73_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c42_l73_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c42_l73_assert_trap() {
    let mut instance = create_module_1();
    let result = c42_l73_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 74
fn c43_l74_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c43_l74_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c43_l74_assert_trap() {
    let mut instance = create_module_1();
    let result = c43_l74_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 75
fn c44_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c44_l75_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c44_l75_assert_trap() {
    let mut instance = create_module_1();
    let result = c44_l75_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 76
fn c45_l76_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c45_l76_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c45_l76_assert_trap() {
    let mut instance = create_module_1();
    let result = c45_l76_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 77
fn c46_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c46_l77_action_invoke");
    let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c46_l77_assert_trap() {
    let mut instance = create_module_1();
    let result = c46_l77_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 79
fn c47_l79_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c47_l79_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 80
fn c48_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c48_l80_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 81
fn c49_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c49_l81_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 82
fn c50_l82_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c50_l82_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 83
fn c51_l83_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c51_l83_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 84
fn c52_l84_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c52_l84_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((1.1f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 85
fn c53_l85_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c53_l85_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((1.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 86
fn c54_l86_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c54_l86_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((1.9f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 87
fn c55_l87_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c55_l87_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((2.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

// Line 88
fn c56_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c56_l88_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((2147483600.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32))));
    result.map(|_| ())
}

// Line 89
fn c57_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c57_l89_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((4294967000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-256 as i32))));
    result.map(|_| ())
}

// Line 90
fn c58_l90_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c58_l90_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.9f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 91
fn c59_l91_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c59_l91_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 92
fn c60_l92_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c60_l92_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((4294967300.0f32).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c60_l92_assert_trap() {
    let mut instance = create_module_1();
    let result = c60_l92_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 93
fn c61_l93_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c61_l93_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32((-1.0f32).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c61_l93_assert_trap() {
    let mut instance = create_module_1();
    let result = c61_l93_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 94
fn c62_l94_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c62_l94_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c62_l94_assert_trap() {
    let mut instance = create_module_1();
    let result = c62_l94_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 95
fn c63_l95_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c63_l95_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c63_l95_assert_trap() {
    let mut instance = create_module_1();
    let result = c63_l95_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 96
fn c64_l96_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c64_l96_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c64_l96_assert_trap() {
    let mut instance = create_module_1();
    let result = c64_l96_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 97
fn c65_l97_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c65_l97_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c65_l97_assert_trap() {
    let mut instance = create_module_1();
    let result = c65_l97_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 98
fn c66_l98_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c66_l98_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c66_l98_assert_trap() {
    let mut instance = create_module_1();
    let result = c66_l98_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 99
fn c67_l99_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c67_l99_action_invoke");
    let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c67_l99_assert_trap() {
    let mut instance = create_module_1();
    let result = c67_l99_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 101
fn c68_l101_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c68_l101_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 102
fn c69_l102_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c69_l102_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 103
fn c70_l103_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c70_l103_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 104
fn c71_l104_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c71_l104_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 105
fn c72_l105_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c72_l105_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((1.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 106
fn c73_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c73_l106_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((1.1f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 107
fn c74_l107_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c74_l107_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((1.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 108
fn c75_l108_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c75_l108_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-1.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 109
fn c76_l109_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c76_l109_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-1.1f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 110
fn c77_l110_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c77_l110_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-1.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 111
fn c78_l111_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c78_l111_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-1.9f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 112
fn c79_l112_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c79_l112_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-2.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-2 as i32))));
    result.map(|_| ())
}

// Line 113
fn c80_l113_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c80_l113_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((2147483647.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32))));
    result.map(|_| ())
}

// Line 114
fn c81_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c81_l114_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-2147483648.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32))));
    result.map(|_| ())
}

// Line 115
fn c82_l115_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c82_l115_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((2147483648.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c82_l115_assert_trap() {
    let mut instance = create_module_1();
    let result = c82_l115_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 116
fn c83_l116_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c83_l116_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64((-2147483649.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c83_l116_assert_trap() {
    let mut instance = create_module_1();
    let result = c83_l116_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 117
fn c84_l117_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c84_l117_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c84_l117_assert_trap() {
    let mut instance = create_module_1();
    let result = c84_l117_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 118
fn c85_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c85_l118_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c85_l118_assert_trap() {
    let mut instance = create_module_1();
    let result = c85_l118_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 119
fn c86_l119_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c86_l119_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c86_l119_assert_trap() {
    let mut instance = create_module_1();
    let result = c86_l119_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 120
fn c87_l120_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c87_l120_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c87_l120_assert_trap() {
    let mut instance = create_module_1();
    let result = c87_l120_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 121
fn c88_l121_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c88_l121_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c88_l121_assert_trap() {
    let mut instance = create_module_1();
    let result = c88_l121_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 122
fn c89_l122_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c89_l122_action_invoke");
    let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c89_l122_assert_trap() {
    let mut instance = create_module_1();
    let result = c89_l122_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 124
fn c90_l124_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c90_l124_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 125
fn c91_l125_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c91_l125_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((-0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 126
fn c92_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c92_l126_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 127
fn c93_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c93_l127_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 128
fn c94_l128_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c94_l128_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((1.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 129
fn c95_l129_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c95_l129_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((1.1f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 130
fn c96_l130_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c96_l130_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((1.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 131
fn c97_l131_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c97_l131_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((1.9f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 132
fn c98_l132_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c98_l132_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((2.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

// Line 133
fn c99_l133_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c99_l133_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((2147483648.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32))));
    result.map(|_| ())
}

// Line 134
fn c100_l134_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c100_l134_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((4294967295.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 135
fn c101_l135_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c101_l135_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((-0.9f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

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

// Line 137
fn c103_l137_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c103_l137_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((100000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(100000000 as i32))));
    result.map(|_| ())
}

// Line 138
fn c104_l138_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c104_l138_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((4294967296.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c104_l138_assert_trap() {
    let mut instance = create_module_1();
    let result = c104_l138_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 139
fn c105_l139_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c105_l139_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((-1.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c105_l139_assert_trap() {
    let mut instance = create_module_1();
    let result = c105_l139_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 140
fn c106_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c106_l140_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((10000000000000000.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c106_l140_assert_trap() {
    let mut instance = create_module_1();
    let result = c106_l140_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 141
fn c107_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c107_l141_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((1000000000000000000000000000000.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c107_l141_assert_trap() {
    let mut instance = create_module_1();
    let result = c107_l141_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 142
fn c108_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c108_l142_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64((9223372036854776000.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c108_l142_assert_trap() {
    let mut instance = create_module_1();
    let result = c108_l142_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 143
fn c109_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c109_l143_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c109_l143_assert_trap() {
    let mut instance = create_module_1();
    let result = c109_l143_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 144
fn c110_l144_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c110_l144_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c110_l144_assert_trap() {
    let mut instance = create_module_1();
    let result = c110_l144_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 145
fn c111_l145_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c111_l145_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c111_l145_assert_trap() {
    let mut instance = create_module_1();
    let result = c111_l145_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 146
fn c112_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c112_l146_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c112_l146_assert_trap() {
    let mut instance = create_module_1();
    let result = c112_l146_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 147
fn c113_l147_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c113_l147_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c113_l147_assert_trap() {
    let mut instance = create_module_1();
    let result = c113_l147_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 148
fn c114_l148_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c114_l148_action_invoke");
    let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c114_l148_assert_trap() {
    let mut instance = create_module_1();
    let result = c114_l148_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 150
fn c115_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c115_l150_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 151
fn c116_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c116_l151_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 152
fn c117_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c117_l152_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 153
fn c118_l153_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c118_l153_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 154
fn c119_l154_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c119_l154_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 155
fn c120_l155_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c120_l155_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((1.1f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 156
fn c121_l156_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c121_l156_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((1.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 157
fn c122_l157_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c122_l157_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 158
fn c123_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c123_l158_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-1.1f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 159
fn c124_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c124_l159_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-1.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 160
fn c125_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c125_l160_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-1.9f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 161
fn c126_l161_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c126_l161_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-2.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-2 as i64))));
    result.map(|_| ())
}

// Line 162
fn c127_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c127_l162_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((4294967300.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(4294967296 as i64))));
    result.map(|_| ())
}

// Line 163
fn c128_l163_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c128_l163_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-4294967300.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-4294967296 as i64))));
    result.map(|_| ())
}

// Line 164
fn c129_l164_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c129_l164_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((9223371500000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(9223371487098961920 as i64))));
    result.map(|_| ())
}

// Line 165
fn c130_l165_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c130_l165_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-9223372000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64))));
    result.map(|_| ())
}

// Line 166
fn c131_l166_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c131_l166_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((9223372000000000000.0f32).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c131_l166_assert_trap() {
    let mut instance = create_module_1();
    let result = c131_l166_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 167
fn c132_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c132_l167_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32((-9223373000000000000.0f32).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c132_l167_assert_trap() {
    let mut instance = create_module_1();
    let result = c132_l167_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 168
fn c133_l168_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c133_l168_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c133_l168_assert_trap() {
    let mut instance = create_module_1();
    let result = c133_l168_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 169
fn c134_l169_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c134_l169_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c134_l169_assert_trap() {
    let mut instance = create_module_1();
    let result = c134_l169_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 170
fn c135_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c135_l170_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c135_l170_assert_trap() {
    let mut instance = create_module_1();
    let result = c135_l170_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 171
fn c136_l171_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c136_l171_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c136_l171_assert_trap() {
    let mut instance = create_module_1();
    let result = c136_l171_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 172
fn c137_l172_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c137_l172_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c137_l172_assert_trap() {
    let mut instance = create_module_1();
    let result = c137_l172_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 173
fn c138_l173_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c138_l173_action_invoke");
    let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c138_l173_assert_trap() {
    let mut instance = create_module_1();
    let result = c138_l173_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 175
fn c139_l175_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c139_l175_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 176
fn c140_l176_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c140_l176_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 177
fn c141_l177_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c141_l177_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 178
fn c142_l178_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c142_l178_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 179
fn c143_l179_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c143_l179_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 180
fn c144_l180_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c144_l180_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((1.1f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 181
fn c145_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c145_l181_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((1.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 182
fn c146_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c146_l182_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((4294967300.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(4294967296 as i64))));
    result.map(|_| ())
}

// Line 183
fn c147_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c147_l183_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((18446743000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1099511627776 as i64))));
    result.map(|_| ())
}

// Line 184
fn c148_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c148_l184_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.9f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 185
fn c149_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c149_l185_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.99999994f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 186
fn c150_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c150_l186_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((18446744000000000000.0f32).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c150_l186_assert_trap() {
    let mut instance = create_module_1();
    let result = c150_l186_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 187
fn c151_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c151_l187_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32((-1.0f32).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c151_l187_assert_trap() {
    let mut instance = create_module_1();
    let result = c151_l187_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 188
fn c152_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c152_l188_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c152_l188_assert_trap() {
    let mut instance = create_module_1();
    let result = c152_l188_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 189
fn c153_l189_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c153_l189_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c153_l189_assert_trap() {
    let mut instance = create_module_1();
    let result = c153_l189_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 190
fn c154_l190_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c154_l190_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c154_l190_assert_trap() {
    let mut instance = create_module_1();
    let result = c154_l190_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 191
fn c155_l191_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c155_l191_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c155_l191_assert_trap() {
    let mut instance = create_module_1();
    let result = c155_l191_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 192
fn c156_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c156_l192_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c156_l192_assert_trap() {
    let mut instance = create_module_1();
    let result = c156_l192_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 193
fn c157_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c157_l193_action_invoke");
    let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]);
    
    result.map(|_| ())
}

#[test]
fn c157_l193_assert_trap() {
    let mut instance = create_module_1();
    let result = c157_l193_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 195
fn c158_l195_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c158_l195_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 196
fn c159_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c159_l196_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 197
fn c160_l197_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c160_l197_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 198
fn c161_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c161_l198_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 199
fn c162_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c162_l199_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((1.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 200
fn c163_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c163_l200_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((1.1f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 201
fn c164_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c164_l201_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((1.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 202
fn c165_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c165_l202_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-1.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 203
fn c166_l203_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c166_l203_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-1.1f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 204
fn c167_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c167_l204_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-1.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 205
fn c168_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c168_l205_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-1.9f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 206
fn c169_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c169_l206_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-2.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-2 as i64))));
    result.map(|_| ())
}

// Line 207
fn c170_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c170_l207_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((4294967296.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(4294967296 as i64))));
    result.map(|_| ())
}

// Line 208
fn c171_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c171_l208_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-4294967296.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-4294967296 as i64))));
    result.map(|_| ())
}

// Line 209
fn c172_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c172_l209_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((9223372036854775000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(9223372036854774784 as i64))));
    result.map(|_| ())
}

// Line 210
fn c173_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c173_l210_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-9223372036854776000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64))));
    result.map(|_| ())
}

// Line 211
fn c174_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c174_l211_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((9223372036854776000.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c174_l211_assert_trap() {
    let mut instance = create_module_1();
    let result = c174_l211_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 212
fn c175_l212_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c175_l212_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64((-9223372036854778000.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c175_l212_assert_trap() {
    let mut instance = create_module_1();
    let result = c175_l212_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 213
fn c176_l213_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c176_l213_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c176_l213_assert_trap() {
    let mut instance = create_module_1();
    let result = c176_l213_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 214
fn c177_l214_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c177_l214_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c177_l214_assert_trap() {
    let mut instance = create_module_1();
    let result = c177_l214_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 215
fn c178_l215_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c178_l215_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c178_l215_assert_trap() {
    let mut instance = create_module_1();
    let result = c178_l215_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 216
fn c179_l216_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c179_l216_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c179_l216_assert_trap() {
    let mut instance = create_module_1();
    let result = c179_l216_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 217
fn c180_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c180_l217_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c180_l217_assert_trap() {
    let mut instance = create_module_1();
    let result = c180_l217_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 218
fn c181_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c181_l218_action_invoke");
    let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c181_l218_assert_trap() {
    let mut instance = create_module_1();
    let result = c181_l218_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 220
fn c182_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c182_l220_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 221
fn c183_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c183_l221_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((-0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 222
fn c184_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c184_l222_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 223
fn c185_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c185_l223_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 224
fn c186_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c186_l224_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((1.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 225
fn c187_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c187_l225_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((1.1f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 226
fn c188_l226_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c188_l226_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((1.5f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 227
fn c189_l227_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c189_l227_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((4294967295.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(4294967295 as i64))));
    result.map(|_| ())
}

// Line 228
fn c190_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c190_l228_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((4294967296.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(4294967296 as i64))));
    result.map(|_| ())
}

// Line 229
fn c191_l229_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c191_l229_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((18446744073709550000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-2048 as i64))));
    result.map(|_| ())
}

// Line 230
fn c192_l230_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c192_l230_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((-0.9f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

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

// Line 232
fn c194_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c194_l232_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((100000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(100000000 as i64))));
    result.map(|_| ())
}

// Line 233
fn c195_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c195_l233_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((10000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(10000000000000000 as i64))));
    result.map(|_| ())
}

// Line 234
fn c196_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c196_l234_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((9223372036854776000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64))));
    result.map(|_| ())
}

// Line 235
fn c197_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c197_l235_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((18446744073709552000.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c197_l235_assert_trap() {
    let mut instance = create_module_1();
    let result = c197_l235_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 236
fn c198_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c198_l236_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64((-1.0f64).to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c198_l236_assert_trap() {
    let mut instance = create_module_1();
    let result = c198_l236_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 237
fn c199_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c199_l237_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c199_l237_assert_trap() {
    let mut instance = create_module_1();
    let result = c199_l237_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 238
fn c200_l238_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c200_l238_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]);
    
    result.map(|_| ())
}

#[test]
fn c200_l238_assert_trap() {
    let mut instance = create_module_1();
    let result = c200_l238_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 239
fn c201_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c201_l239_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c201_l239_assert_trap() {
    let mut instance = create_module_1();
    let result = c201_l239_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 240
fn c202_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c202_l240_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c202_l240_assert_trap() {
    let mut instance = create_module_1();
    let result = c202_l240_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 241
fn c203_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c203_l241_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c203_l241_assert_trap() {
    let mut instance = create_module_1();
    let result = c203_l241_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 242
fn c204_l242_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c204_l242_action_invoke");
    let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]);
    
    result.map(|_| ())
}

#[test]
fn c204_l242_assert_trap() {
    let mut instance = create_module_1();
    let result = c204_l242_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 244
fn c205_l244_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c205_l244_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 245
fn c206_l245_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c206_l245_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(-1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 246
fn c207_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c207_l246_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(0 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 247
fn c208_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c208_l247_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(2147483647 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((2147483600.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 248
fn c209_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c209_l248_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(-2147483648 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((-2147483600.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 249
fn c210_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c210_l249_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(1234567890 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((1234568000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 251
fn c211_l251_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c211_l251_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(16777217 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 252
fn c212_l252_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c212_l252_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(-16777217 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((-16777216.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 253
fn c213_l253_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c213_l253_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(16777219 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 254
fn c214_l254_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c214_l254_action_invoke");
    let result = instance.call("f32.convert_s_i32", &[Value::I32(-16777219 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((-16777220.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 256
fn c215_l256_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c215_l256_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 257
fn c216_l257_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c216_l257_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(-1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 258
fn c217_l258_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c217_l258_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(0 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 259
fn c218_l259_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c218_l259_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(9223372036854775807 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 260
fn c219_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c219_l260_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(-9223372036854775808 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((-9223372000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 261
fn c220_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c220_l261_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(314159265358979 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((314159280000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 263
fn c221_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c221_l263_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(16777217 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 264
fn c222_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c222_l264_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(-16777217 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((-16777216.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 265
fn c223_l265_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c223_l265_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(16777219 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 266
fn c224_l266_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c224_l266_action_invoke");
    let result = instance.call("f32.convert_s_i64", &[Value::I64(-16777219 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((-16777220.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 268
fn c225_l268_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c225_l268_action_invoke");
    let result = instance.call("f64.convert_s_i32", &[Value::I32(1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 269
fn c226_l269_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c226_l269_action_invoke");
    let result = instance.call("f64.convert_s_i32", &[Value::I32(-1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 270
fn c227_l270_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c227_l270_action_invoke");
    let result = instance.call("f64.convert_s_i32", &[Value::I32(0 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 271
fn c228_l271_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c228_l271_action_invoke");
    let result = instance.call("f64.convert_s_i32", &[Value::I32(2147483647 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((2147483647.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 272
fn c229_l272_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c229_l272_action_invoke");
    let result = instance.call("f64.convert_s_i32", &[Value::I32(-2147483648 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((-2147483648.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 273
fn c230_l273_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c230_l273_action_invoke");
    let result = instance.call("f64.convert_s_i32", &[Value::I32(987654321 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((987654321.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 275
fn c231_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c231_l275_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 276
fn c232_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c232_l276_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(-1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 277
fn c233_l277_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c233_l277_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(0 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 278
fn c234_l278_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c234_l278_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(9223372036854775807 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 279
fn c235_l279_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c235_l279_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(-9223372036854775808 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((-9223372036854776000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 280
fn c236_l280_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c236_l280_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(4669201609102990 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((4669201609102990.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 282
fn c237_l282_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c237_l282_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(9007199254740993 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9007199254740992.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 283
fn c238_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c238_l283_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(-9007199254740993 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((-9007199254740992.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 284
fn c239_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c239_l284_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(9007199254740995 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9007199254740996.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 285
fn c240_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c240_l285_action_invoke");
    let result = instance.call("f64.convert_s_i64", &[Value::I64(-9007199254740995 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((-9007199254740996.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 287
fn c241_l287_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c241_l287_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 288
fn c242_l288_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c242_l288_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(0 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 289
fn c243_l289_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c243_l289_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(2147483647 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((2147483600.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 290
fn c244_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c244_l290_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(-2147483648 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((2147483600.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 291
fn c245_l291_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c245_l291_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(305419896 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((305419900.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 292
fn c246_l292_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c246_l292_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(-1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((4294967300.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 293
fn c247_l293_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c247_l293_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(-2147483520 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((2147483600.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 294
fn c248_l294_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c248_l294_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(-2147483519 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((2147484000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 295
fn c249_l295_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c249_l295_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(-2147483518 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((2147484000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 296
fn c250_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c250_l296_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(-384 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((4294966800.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 297
fn c251_l297_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c251_l297_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(-383 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((4294967000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 298
fn c252_l298_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c252_l298_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(-382 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((4294967000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 300
fn c253_l300_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c253_l300_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(16777217 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 301
fn c254_l301_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c254_l301_action_invoke");
    let result = instance.call("f32.convert_u_i32", &[Value::I32(16777219 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 303
fn c255_l303_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c255_l303_action_invoke");
    let result = instance.call("f32.convert_u_i64", &[Value::I64(1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 304
fn c256_l304_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c256_l304_action_invoke");
    let result = instance.call("f32.convert_u_i64", &[Value::I64(0 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 305
fn c257_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c257_l305_action_invoke");
    let result = instance.call("f32.convert_u_i64", &[Value::I64(9223372036854775807 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 306
fn c258_l306_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c258_l306_action_invoke");
    let result = instance.call("f32.convert_u_i64", &[Value::I64(-9223372036854775808 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 307
fn c259_l307_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c259_l307_action_invoke");
    let result = instance.call("f32.convert_u_i64", &[Value::I64(-1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((18446744000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 309
fn c260_l309_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c260_l309_action_invoke");
    let result = instance.call("f32.convert_u_i64", &[Value::I64(16777217 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 310
fn c261_l310_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c261_l310_action_invoke");
    let result = instance.call("f32.convert_u_i64", &[Value::I64(16777219 as i64)]);
    assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 312
fn c262_l312_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c262_l312_action_invoke");
    let result = instance.call("f64.convert_u_i32", &[Value::I32(1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 313
fn c263_l313_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c263_l313_action_invoke");
    let result = instance.call("f64.convert_u_i32", &[Value::I32(0 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 314
fn c264_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c264_l314_action_invoke");
    let result = instance.call("f64.convert_u_i32", &[Value::I32(2147483647 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((2147483647.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 315
fn c265_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c265_l315_action_invoke");
    let result = instance.call("f64.convert_u_i32", &[Value::I32(-2147483648 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((2147483648.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 316
fn c266_l316_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c266_l316_action_invoke");
    let result = instance.call("f64.convert_u_i32", &[Value::I32(-1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F64((4294967295.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 318
fn c267_l318_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c267_l318_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 319
fn c268_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c268_l319_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(0 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 320
fn c269_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c269_l320_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(9223372036854775807 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 321
fn c270_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c270_l321_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854775808 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 322
fn c271_l322_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c271_l322_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(-1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((18446744073709552000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 323
fn c272_l323_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c272_l323_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774784 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 324
fn c273_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c273_l324_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774783 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 325
fn c274_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c274_l325_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774782 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 326
fn c275_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c275_l326_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(-3072 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((18446744073709548000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 327
fn c276_l327_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c276_l327_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(-3071 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((18446744073709550000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 328
fn c277_l328_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c277_l328_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(-3070 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((18446744073709550000.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 330
fn c278_l330_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c278_l330_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(9007199254740993 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9007199254740992.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 331
fn c279_l331_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c279_l331_action_invoke");
    let result = instance.call("f64.convert_u_i64", &[Value::I64(9007199254740995 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((9007199254740996.0f64).to_bits()))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

// Line 342
fn c288_l342_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c288_l342_action_invoke");
    let result = instance.call("f64.promote_f32", &[Value::F32((0.0000000000000000000000000000000000015046328f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000001504632769052528f64).to_bits()))));
    result.map(|_| ())
}

// Line 344
fn c289_l344_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c289_l344_action_invoke");
    let result = instance.call("f64.promote_f32", &[Value::F32((66382537000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F64((66382536710104395000000000000000000000.0f64).to_bits()))));
    result.map(|_| ())
}

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

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

// Line 347
fn c292_l347_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c292_l347_assert_return_canonical_nan");
    let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c292_l347_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 348
fn c293_l348_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c293_l348_assert_return_arithmetic_nan");
    let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c293_l348_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 349
fn c294_l349_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c294_l349_assert_return_canonical_nan");
    let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c294_l349_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 350
fn c295_l350_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c295_l350_assert_return_arithmetic_nan");
    let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c295_l350_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

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

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

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

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

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

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

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

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

// Line 360
fn c304_l360_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c304_l360_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000011754942807573642f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 361
fn c305_l361_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c305_l361_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000011754942807573642f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

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

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

// Line 373
fn c317_l373_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c317_l373_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((-340282356779733660000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 374
fn c318_l374_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c318_l374_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000001504632769052528f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000015046328f32).to_bits()))));
    result.map(|_| ())
}

// Line 375
fn c319_l375_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c319_l375_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((66382536710104395000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((66382537000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

// Line 385
fn c329_l385_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c329_l385_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((16777217.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 386
fn c330_l386_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c330_l386_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((16777217.000000004f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((16777218.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 387
fn c331_l387_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c331_l387_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((16777218.999999996f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((16777218.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 388
fn c332_l388_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c332_l388_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((16777219.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 389
fn c333_l389_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c333_l389_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((424258443299142700000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((424258450000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 390
fn c334_l390_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c334_l390_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000001569262107843488f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000015692621f32).to_bits()))));
    result.map(|_| ())
}

// Line 391
fn c335_l391_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c335_l391_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000010551773688605172f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000010551773f32).to_bits()))));
    result.map(|_| ())
}

// Line 392
fn c336_l392_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c336_l392_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((-2.8238128484141933f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-2.823813f32).to_bits()))));
    result.map(|_| ())
}

// Line 393
fn c337_l393_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c337_l393_action_invoke");
    let result = instance.call("f32.demote_f64", &[Value::F64((-9063376370095757000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-9063376000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 394
fn c338_l394_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c338_l394_assert_return_canonical_nan");
    let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c338_l394_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 395
fn c339_l395_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c339_l395_assert_return_arithmetic_nan");
    let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c339_l395_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 396
fn c340_l396_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c340_l396_assert_return_canonical_nan");
    let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c340_l396_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 397
fn c341_l397_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c341_l397_assert_return_arithmetic_nan");
    let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c341_l397_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

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

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

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

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

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

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

// Line 405
fn c348_l405_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c348_l405_action_invoke");
    let result = instance.call("f32.reinterpret_i32", &[Value::I32(0 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 406
fn c349_l406_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c349_l406_action_invoke");
    let result = instance.call("f32.reinterpret_i32", &[Value::I32(-2147483648 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 407
fn c350_l407_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c350_l407_action_invoke");
    let result = instance.call("f32.reinterpret_i32", &[Value::I32(1 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

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

// Line 409
fn c352_l409_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c352_l409_action_invoke");
    let result = instance.call("f32.reinterpret_i32", &[Value::I32(123456789 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000016535997f32).to_bits()))));
    result.map(|_| ())
}

// Line 410
fn c353_l410_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c353_l410_action_invoke");
    let result = instance.call("f32.reinterpret_i32", &[Value::I32(-2147483647 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

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

// Line 412
fn c355_l412_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c355_l412_action_invoke");
    let result = instance.call("f32.reinterpret_i32", &[Value::I32(-8388608 as i32)]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

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

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

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

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

// Line 418
fn c360_l418_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c360_l418_action_invoke");
    let result = instance.call("f64.reinterpret_i64", &[Value::I64(0 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 419
fn c361_l419_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c361_l419_action_invoke");
    let result = instance.call("f64.reinterpret_i64", &[Value::I64(1 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()))));
    result.map(|_| ())
}

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

// Line 421
fn c363_l421_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c363_l421_action_invoke");
    let result = instance.call("f64.reinterpret_i64", &[Value::I64(-9223372036854775808 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits()))));
    result.map(|_| ())
}

// Line 422
fn c364_l422_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c364_l422_action_invoke");
    let result = instance.call("f64.reinterpret_i64", &[Value::I64(1234567890 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000609957582f64).to_bits()))));
    result.map(|_| ())
}

// Line 423
fn c365_l423_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c365_l423_action_invoke");
    let result = instance.call("f64.reinterpret_i64", &[Value::I64(-9223372036854775807 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()))));
    result.map(|_| ())
}

// Line 424
fn c366_l424_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c366_l424_action_invoke");
    let result = instance.call("f64.reinterpret_i64", &[Value::I64(9218868437227405312 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 425
fn c367_l425_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c367_l425_action_invoke");
    let result = instance.call("f64.reinterpret_i64", &[Value::I64(-4503599627370496 as i64)]);
    assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

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

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

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

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

// Line 431
fn c372_l431_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c372_l431_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(0 as i32))));
    result.map(|_| ())
}

// Line 432
fn c373_l432_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c373_l432_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32))));
    result.map(|_| ())
}

// Line 433
fn c374_l433_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c374_l433_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1 as i32))));
    result.map(|_| ())
}

// Line 434
fn c375_l434_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c375_l434_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4294967295) as u32)]);
    assert_eq!(result, Ok(Some(Value::I32(-1 as i32))));
    result.map(|_| ())
}

// Line 435
fn c376_l435_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c376_l435_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-2147483647 as i32))));
    result.map(|_| ())
}

// Line 436
fn c377_l436_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c377_l436_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1065353216 as i32))));
    result.map(|_| ())
}

// Line 437
fn c378_l437_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c378_l437_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32((3.1415925f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(1078530010 as i32))));
    result.map(|_| ())
}

// Line 438
fn c379_l438_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c379_l438_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(2139095039 as i32))));
    result.map(|_| ())
}

// Line 439
fn c380_l439_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c380_l439_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-8388609 as i32))));
    result.map(|_| ())
}

// Line 440
fn c381_l440_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c381_l440_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(2139095040 as i32))));
    result.map(|_| ())
}

// Line 441
fn c382_l441_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c382_l441_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::I32(-8388608 as i32))));
    result.map(|_| ())
}

// Line 442
fn c383_l442_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c383_l442_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]);
    assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32))));
    result.map(|_| ())
}

// Line 443
fn c384_l443_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c384_l443_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]);
    assert_eq!(result, Ok(Some(Value::I32(-4194304 as i32))));
    result.map(|_| ())
}

// Line 444
fn c385_l444_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c385_l444_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]);
    assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32))));
    result.map(|_| ())
}

// Line 445
fn c386_l445_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c386_l445_action_invoke");
    let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]);
    assert_eq!(result, Ok(Some(Value::I32(-6291456 as i32))));
    result.map(|_| ())
}

// Line 447
fn c387_l447_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c387_l447_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64((0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(0 as i64))));
    result.map(|_| ())
}

// Line 448
fn c388_l448_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c388_l448_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64((-0.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64))));
    result.map(|_| ())
}

// Line 449
fn c389_l449_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c389_l449_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(1 as i64))));
    result.map(|_| ())
}

// Line 450
fn c390_l450_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c390_l450_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18446744073709551615) as u64)]);
    assert_eq!(result, Ok(Some(Value::I64(-1 as i64))));
    result.map(|_| ())
}

// Line 451
fn c391_l451_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c391_l451_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-9223372036854775807 as i64))));
    result.map(|_| ())
}

// Line 452
fn c392_l452_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c392_l452_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64((1.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(4607182418800017408 as i64))));
    result.map(|_| ())
}

// Line 453
fn c393_l453_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c393_l453_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64((3.14159265358979f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(4614256656552045841 as i64))));
    result.map(|_| ())
}

// Line 454
fn c394_l454_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c394_l454_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(9218868437227405311 as i64))));
    result.map(|_| ())
}

// Line 455
fn c395_l455_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c395_l455_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-4503599627370497 as i64))));
    result.map(|_| ())
}

// Line 456
fn c396_l456_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c396_l456_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(9218868437227405312 as i64))));
    result.map(|_| ())
}

// Line 457
fn c397_l457_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c397_l457_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::I64(-4503599627370496 as i64))));
    result.map(|_| ())
}

// Line 458
fn c398_l458_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c398_l458_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]);
    assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64))));
    result.map(|_| ())
}

// Line 459
fn c399_l459_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c399_l459_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]);
    assert_eq!(result, Ok(Some(Value::I64(-2251799813685248 as i64))));
    result.map(|_| ())
}

// Line 460
fn c400_l460_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c400_l460_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]);
    assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64))));
    result.map(|_| ())
}

// Line 461
fn c401_l461_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c401_l461_action_invoke");
    let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]);
    assert_eq!(result, Ok(Some(Value::I64(-3377699720527872 as i64))));
    result.map(|_| ())
}

#[test]
fn test_module_1() {
    let mut instance = create_module_1();
    // We group the calls together
    start_module_1(&mut instance);
    c1_l29_action_invoke(&mut instance);
    c2_l30_action_invoke(&mut instance);
    c3_l31_action_invoke(&mut instance);
    c4_l32_action_invoke(&mut instance);
    c5_l33_action_invoke(&mut instance);
    c6_l34_action_invoke(&mut instance);
    c7_l36_action_invoke(&mut instance);
    c8_l37_action_invoke(&mut instance);
    c9_l38_action_invoke(&mut instance);
    c10_l39_action_invoke(&mut instance);
    c11_l40_action_invoke(&mut instance);
    c12_l41_action_invoke(&mut instance);
    c13_l43_action_invoke(&mut instance);
    c14_l44_action_invoke(&mut instance);
    c15_l45_action_invoke(&mut instance);
    c16_l46_action_invoke(&mut instance);
    c17_l47_action_invoke(&mut instance);
    c18_l48_action_invoke(&mut instance);
    c19_l49_action_invoke(&mut instance);
    c20_l50_action_invoke(&mut instance);
    c21_l51_action_invoke(&mut instance);
    c22_l52_action_invoke(&mut instance);
    c23_l53_action_invoke(&mut instance);
    c24_l54_action_invoke(&mut instance);
    c25_l56_action_invoke(&mut instance);
    c26_l57_action_invoke(&mut instance);
    c27_l58_action_invoke(&mut instance);
    c28_l59_action_invoke(&mut instance);
    c29_l60_action_invoke(&mut instance);
    c30_l61_action_invoke(&mut instance);
    c31_l62_action_invoke(&mut instance);
    c32_l63_action_invoke(&mut instance);
    c33_l64_action_invoke(&mut instance);
    c34_l65_action_invoke(&mut instance);
    c35_l66_action_invoke(&mut instance);
    c36_l67_action_invoke(&mut instance);
    c37_l68_action_invoke(&mut instance);
    c38_l69_action_invoke(&mut instance);
    c47_l79_action_invoke(&mut instance);
    c48_l80_action_invoke(&mut instance);
    c49_l81_action_invoke(&mut instance);
    c50_l82_action_invoke(&mut instance);
    c51_l83_action_invoke(&mut instance);
    c52_l84_action_invoke(&mut instance);
    c53_l85_action_invoke(&mut instance);
    c54_l86_action_invoke(&mut instance);
    c55_l87_action_invoke(&mut instance);
    c56_l88_action_invoke(&mut instance);
    c57_l89_action_invoke(&mut instance);
    c58_l90_action_invoke(&mut instance);
    c59_l91_action_invoke(&mut instance);
    c68_l101_action_invoke(&mut instance);
    c69_l102_action_invoke(&mut instance);
    c70_l103_action_invoke(&mut instance);
    c71_l104_action_invoke(&mut instance);
    c72_l105_action_invoke(&mut instance);
    c73_l106_action_invoke(&mut instance);
    c74_l107_action_invoke(&mut instance);
    c75_l108_action_invoke(&mut instance);
    c76_l109_action_invoke(&mut instance);
    c77_l110_action_invoke(&mut instance);
    c78_l111_action_invoke(&mut instance);
    c79_l112_action_invoke(&mut instance);
    c80_l113_action_invoke(&mut instance);
    c81_l114_action_invoke(&mut instance);
    c90_l124_action_invoke(&mut instance);
    c91_l125_action_invoke(&mut instance);
    c92_l126_action_invoke(&mut instance);
    c93_l127_action_invoke(&mut instance);
    c94_l128_action_invoke(&mut instance);
    c95_l129_action_invoke(&mut instance);
    c96_l130_action_invoke(&mut instance);
    c97_l131_action_invoke(&mut instance);
    c98_l132_action_invoke(&mut instance);
    c99_l133_action_invoke(&mut instance);
    c100_l134_action_invoke(&mut instance);
    c101_l135_action_invoke(&mut instance);
    c102_l136_action_invoke(&mut instance);
    c103_l137_action_invoke(&mut instance);
    c115_l150_action_invoke(&mut instance);
    c116_l151_action_invoke(&mut instance);
    c117_l152_action_invoke(&mut instance);
    c118_l153_action_invoke(&mut instance);
    c119_l154_action_invoke(&mut instance);
    c120_l155_action_invoke(&mut instance);
    c121_l156_action_invoke(&mut instance);
    c122_l157_action_invoke(&mut instance);
    c123_l158_action_invoke(&mut instance);
    c124_l159_action_invoke(&mut instance);
    c125_l160_action_invoke(&mut instance);
    c126_l161_action_invoke(&mut instance);
    c127_l162_action_invoke(&mut instance);
    c128_l163_action_invoke(&mut instance);
    c129_l164_action_invoke(&mut instance);
    c130_l165_action_invoke(&mut instance);
    c139_l175_action_invoke(&mut instance);
    c140_l176_action_invoke(&mut instance);
    c141_l177_action_invoke(&mut instance);
    c142_l178_action_invoke(&mut instance);
    c143_l179_action_invoke(&mut instance);
    c144_l180_action_invoke(&mut instance);
    c145_l181_action_invoke(&mut instance);
    c146_l182_action_invoke(&mut instance);
    c147_l183_action_invoke(&mut instance);
    c148_l184_action_invoke(&mut instance);
    c149_l185_action_invoke(&mut instance);
    c158_l195_action_invoke(&mut instance);
    c159_l196_action_invoke(&mut instance);
    c160_l197_action_invoke(&mut instance);
    c161_l198_action_invoke(&mut instance);
    c162_l199_action_invoke(&mut instance);
    c163_l200_action_invoke(&mut instance);
    c164_l201_action_invoke(&mut instance);
    c165_l202_action_invoke(&mut instance);
    c166_l203_action_invoke(&mut instance);
    c167_l204_action_invoke(&mut instance);
    c168_l205_action_invoke(&mut instance);
    c169_l206_action_invoke(&mut instance);
    c170_l207_action_invoke(&mut instance);
    c171_l208_action_invoke(&mut instance);
    c172_l209_action_invoke(&mut instance);
    c173_l210_action_invoke(&mut instance);
    c182_l220_action_invoke(&mut instance);
    c183_l221_action_invoke(&mut instance);
    c184_l222_action_invoke(&mut instance);
    c185_l223_action_invoke(&mut instance);
    c186_l224_action_invoke(&mut instance);
    c187_l225_action_invoke(&mut instance);
    c188_l226_action_invoke(&mut instance);
    c189_l227_action_invoke(&mut instance);
    c190_l228_action_invoke(&mut instance);
    c191_l229_action_invoke(&mut instance);
    c192_l230_action_invoke(&mut instance);
    c193_l231_action_invoke(&mut instance);
    c194_l232_action_invoke(&mut instance);
    c195_l233_action_invoke(&mut instance);
    c196_l234_action_invoke(&mut instance);
    c205_l244_action_invoke(&mut instance);
    c206_l245_action_invoke(&mut instance);
    c207_l246_action_invoke(&mut instance);
    c208_l247_action_invoke(&mut instance);
    c209_l248_action_invoke(&mut instance);
    c210_l249_action_invoke(&mut instance);
    c211_l251_action_invoke(&mut instance);
    c212_l252_action_invoke(&mut instance);
    c213_l253_action_invoke(&mut instance);
    c214_l254_action_invoke(&mut instance);
    c215_l256_action_invoke(&mut instance);
    c216_l257_action_invoke(&mut instance);
    c217_l258_action_invoke(&mut instance);
    c218_l259_action_invoke(&mut instance);
    c219_l260_action_invoke(&mut instance);
    c220_l261_action_invoke(&mut instance);
    c221_l263_action_invoke(&mut instance);
    c222_l264_action_invoke(&mut instance);
    c223_l265_action_invoke(&mut instance);
    c224_l266_action_invoke(&mut instance);
    c225_l268_action_invoke(&mut instance);
    c226_l269_action_invoke(&mut instance);
    c227_l270_action_invoke(&mut instance);
    c228_l271_action_invoke(&mut instance);
    c229_l272_action_invoke(&mut instance);
    c230_l273_action_invoke(&mut instance);
    c231_l275_action_invoke(&mut instance);
    c232_l276_action_invoke(&mut instance);
    c233_l277_action_invoke(&mut instance);
    c234_l278_action_invoke(&mut instance);
    c235_l279_action_invoke(&mut instance);
    c236_l280_action_invoke(&mut instance);
    c237_l282_action_invoke(&mut instance);
    c238_l283_action_invoke(&mut instance);
    c239_l284_action_invoke(&mut instance);
    c240_l285_action_invoke(&mut instance);
    c241_l287_action_invoke(&mut instance);
    c242_l288_action_invoke(&mut instance);
    c243_l289_action_invoke(&mut instance);
    c244_l290_action_invoke(&mut instance);
    c245_l291_action_invoke(&mut instance);
    c246_l292_action_invoke(&mut instance);
    c247_l293_action_invoke(&mut instance);
    c248_l294_action_invoke(&mut instance);
    c249_l295_action_invoke(&mut instance);
    c250_l296_action_invoke(&mut instance);
    c251_l297_action_invoke(&mut instance);
    c252_l298_action_invoke(&mut instance);
    c253_l300_action_invoke(&mut instance);
    c254_l301_action_invoke(&mut instance);
    c255_l303_action_invoke(&mut instance);
    c256_l304_action_invoke(&mut instance);
    c257_l305_action_invoke(&mut instance);
    c258_l306_action_invoke(&mut instance);
    c259_l307_action_invoke(&mut instance);
    c260_l309_action_invoke(&mut instance);
    c261_l310_action_invoke(&mut instance);
    c262_l312_action_invoke(&mut instance);
    c263_l313_action_invoke(&mut instance);
    c264_l314_action_invoke(&mut instance);
    c265_l315_action_invoke(&mut instance);
    c266_l316_action_invoke(&mut instance);
    c267_l318_action_invoke(&mut instance);
    c268_l319_action_invoke(&mut instance);
    c269_l320_action_invoke(&mut instance);
    c270_l321_action_invoke(&mut instance);
    c271_l322_action_invoke(&mut instance);
    c272_l323_action_invoke(&mut instance);
    c273_l324_action_invoke(&mut instance);
    c274_l325_action_invoke(&mut instance);
    c275_l326_action_invoke(&mut instance);
    c276_l327_action_invoke(&mut instance);
    c277_l328_action_invoke(&mut instance);
    c278_l330_action_invoke(&mut instance);
    c279_l331_action_invoke(&mut instance);
    c280_l333_action_invoke(&mut instance);
    c281_l334_action_invoke(&mut instance);
    c282_l335_action_invoke(&mut instance);
    c283_l336_action_invoke(&mut instance);
    c284_l337_action_invoke(&mut instance);
    c285_l338_action_invoke(&mut instance);
    c286_l339_action_invoke(&mut instance);
    c287_l340_action_invoke(&mut instance);
    c288_l342_action_invoke(&mut instance);
    c289_l344_action_invoke(&mut instance);
    c290_l345_action_invoke(&mut instance);
    c291_l346_action_invoke(&mut instance);
    c292_l347_assert_return_canonical_nan(&mut instance);
    c293_l348_assert_return_arithmetic_nan(&mut instance);
    c294_l349_assert_return_canonical_nan(&mut instance);
    c295_l350_assert_return_arithmetic_nan(&mut instance);
    c296_l352_action_invoke(&mut instance);
    c297_l353_action_invoke(&mut instance);
    c298_l354_action_invoke(&mut instance);
    c299_l355_action_invoke(&mut instance);
    c300_l356_action_invoke(&mut instance);
    c301_l357_action_invoke(&mut instance);
    c302_l358_action_invoke(&mut instance);
    c303_l359_action_invoke(&mut instance);
    c304_l360_action_invoke(&mut instance);
    c305_l361_action_invoke(&mut instance);
    c306_l362_action_invoke(&mut instance);
    c307_l363_action_invoke(&mut instance);
    c308_l364_action_invoke(&mut instance);
    c309_l365_action_invoke(&mut instance);
    c310_l366_action_invoke(&mut instance);
    c311_l367_action_invoke(&mut instance);
    c312_l368_action_invoke(&mut instance);
    c313_l369_action_invoke(&mut instance);
    c314_l370_action_invoke(&mut instance);
    c315_l371_action_invoke(&mut instance);
    c316_l372_action_invoke(&mut instance);
    c317_l373_action_invoke(&mut instance);
    c318_l374_action_invoke(&mut instance);
    c319_l375_action_invoke(&mut instance);
    c320_l376_action_invoke(&mut instance);
    c321_l377_action_invoke(&mut instance);
    c322_l378_action_invoke(&mut instance);
    c323_l379_action_invoke(&mut instance);
    c324_l380_action_invoke(&mut instance);
    c325_l381_action_invoke(&mut instance);
    c326_l382_action_invoke(&mut instance);
    c327_l383_action_invoke(&mut instance);
    c328_l384_action_invoke(&mut instance);
    c329_l385_action_invoke(&mut instance);
    c330_l386_action_invoke(&mut instance);
    c331_l387_action_invoke(&mut instance);
    c332_l388_action_invoke(&mut instance);
    c333_l389_action_invoke(&mut instance);
    c334_l390_action_invoke(&mut instance);
    c335_l391_action_invoke(&mut instance);
    c336_l392_action_invoke(&mut instance);
    c337_l393_action_invoke(&mut instance);
    c338_l394_assert_return_canonical_nan(&mut instance);
    c339_l395_assert_return_arithmetic_nan(&mut instance);
    c340_l396_assert_return_canonical_nan(&mut instance);
    c341_l397_assert_return_arithmetic_nan(&mut instance);
    c342_l398_action_invoke(&mut instance);
    c343_l399_action_invoke(&mut instance);
    c344_l400_action_invoke(&mut instance);
    c345_l401_action_invoke(&mut instance);
    c346_l402_action_invoke(&mut instance);
    c347_l403_action_invoke(&mut instance);
    c348_l405_action_invoke(&mut instance);
    c349_l406_action_invoke(&mut instance);
    c350_l407_action_invoke(&mut instance);
    c351_l408_action_invoke(&mut instance);
    c352_l409_action_invoke(&mut instance);
    c353_l410_action_invoke(&mut instance);
    c354_l411_action_invoke(&mut instance);
    c355_l412_action_invoke(&mut instance);
    c356_l413_action_invoke(&mut instance);
    c357_l414_action_invoke(&mut instance);
    c358_l415_action_invoke(&mut instance);
    c359_l416_action_invoke(&mut instance);
    c360_l418_action_invoke(&mut instance);
    c361_l419_action_invoke(&mut instance);
    c362_l420_action_invoke(&mut instance);
    c363_l421_action_invoke(&mut instance);
    c364_l422_action_invoke(&mut instance);
    c365_l423_action_invoke(&mut instance);
    c366_l424_action_invoke(&mut instance);
    c367_l425_action_invoke(&mut instance);
    c368_l426_action_invoke(&mut instance);
    c369_l427_action_invoke(&mut instance);
    c370_l428_action_invoke(&mut instance);
    c371_l429_action_invoke(&mut instance);
    c372_l431_action_invoke(&mut instance);
    c373_l432_action_invoke(&mut instance);
    c374_l433_action_invoke(&mut instance);
    c375_l434_action_invoke(&mut instance);
    c376_l435_action_invoke(&mut instance);
    c377_l436_action_invoke(&mut instance);
    c378_l437_action_invoke(&mut instance);
    c379_l438_action_invoke(&mut instance);
    c380_l439_action_invoke(&mut instance);
    c381_l440_action_invoke(&mut instance);
    c382_l441_action_invoke(&mut instance);
    c383_l442_action_invoke(&mut instance);
    c384_l443_action_invoke(&mut instance);
    c385_l444_action_invoke(&mut instance);
    c386_l445_action_invoke(&mut instance);
    c387_l447_action_invoke(&mut instance);
    c388_l448_action_invoke(&mut instance);
    c389_l449_action_invoke(&mut instance);
    c390_l450_action_invoke(&mut instance);
    c391_l451_action_invoke(&mut instance);
    c392_l452_action_invoke(&mut instance);
    c393_l453_action_invoke(&mut instance);
    c394_l454_action_invoke(&mut instance);
    c395_l455_action_invoke(&mut instance);
    c396_l456_action_invoke(&mut instance);
    c397_l457_action_invoke(&mut instance);
    c398_l458_action_invoke(&mut instance);
    c399_l459_action_invoke(&mut instance);
    c400_l460_action_invoke(&mut instance);
    c401_l461_action_invoke(&mut instance);
}