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

use wasmer_runtime::types::Value;
use wasmer_runtime::{Instance, module::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 (result i32)))
      (type (;1;) (func (param i32 i32)))
      (type (;2;) (func (param i32) (result i32)))
      (func (;0;) (type 0) (result i32)
        memory.size
        i32.const 65536
        i32.mul)
      (func (;1;) (type 1) (param i32 i32)
        call 0
        get_local 0
        i32.add
        get_local 1
        i32.store)
      (func (;2;) (type 2) (param i32) (result i32)
        call 0
        get_local 0
        i32.add
        i32.load)
      (func (;3;) (type 2) (param i32) (result i32)
        get_local 0
        memory.grow)
      (memory (;0;) 1)
      (export \"store\" (func 1))
      (export \"load\" (func 2))
      (export \"memory.grow\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
    module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
}

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

// Line 21
fn c1_l21_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1_l21_action_invoke");
    let result = instance.call("store", &[Value::I32(-4 as i32), Value::I32(42 as i32)]);
    assert_eq!(result, Ok(None));
    result.map(|_| ())
}

// Line 22
fn c2_l22_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2_l22_action_invoke");
    let result = instance.call("load", &[Value::I32(-4 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(42 as i32))));
    result.map(|_| ())
}

// Line 23
fn c3_l23_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c3_l23_action_invoke");
    let result = instance.call("store", &[Value::I32(-3 as i32), Value::I32(13 as i32)]);
    
    result.map(|_| ())
}

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

// Line 24
fn c4_l24_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c4_l24_action_invoke");
    let result = instance.call("load", &[Value::I32(-3 as i32)]);
    
    result.map(|_| ())
}

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

// Line 25
fn c5_l25_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c5_l25_action_invoke");
    let result = instance.call("store", &[Value::I32(-2 as i32), Value::I32(13 as i32)]);
    
    result.map(|_| ())
}

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

// Line 26
fn c6_l26_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c6_l26_action_invoke");
    let result = instance.call("load", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

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

// Line 27
fn c7_l27_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c7_l27_action_invoke");
    let result = instance.call("store", &[Value::I32(-1 as i32), Value::I32(13 as i32)]);
    
    result.map(|_| ())
}

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

// Line 28
fn c8_l28_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c8_l28_action_invoke");
    let result = instance.call("load", &[Value::I32(-1 as i32)]);
    
    result.map(|_| ())
}

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

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

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

// Line 30
fn c10_l30_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c10_l30_action_invoke");
    let result = instance.call("load", &[Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

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

// Line 31
fn c11_l31_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c11_l31_action_invoke");
    let result = instance.call("store", &[Value::I32(-2147483648 as i32), Value::I32(13 as i32)]);
    
    result.map(|_| ())
}

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

// Line 32
fn c12_l32_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c12_l32_action_invoke");
    let result = instance.call("load", &[Value::I32(-2147483648 as i32)]);
    
    result.map(|_| ())
}

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

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

// Line 35

#[test]
fn test_module_1() {
    let mut instance = create_module_1();
    // We group the calls together
    start_module_1(&mut instance);
    c1_l21_action_invoke(&mut instance);
    c2_l22_action_invoke(&mut instance);
    c13_l33_action_invoke(&mut instance);
}
fn create_module_2() -> Box<Instance> {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i32) (result i64)))
      (type (;2;) (func (param i32) (result f32)))
      (type (;3;) (func (param i32) (result f64)))
      (type (;4;) (func (param i32 i32)))
      (type (;5;) (func (param i32 i64)))
      (type (;6;) (func (param i32 f32)))
      (type (;7;) (func (param i32 f64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.load)
      (func (;1;) (type 1) (param i32) (result i64)
        get_local 0
        i64.load)
      (func (;2;) (type 2) (param i32) (result f32)
        get_local 0
        f32.load)
      (func (;3;) (type 3) (param i32) (result f64)
        get_local 0
        f64.load)
      (func (;4;) (type 0) (param i32) (result i32)
        get_local 0
        i32.load8_s)
      (func (;5;) (type 0) (param i32) (result i32)
        get_local 0
        i32.load8_u)
      (func (;6;) (type 0) (param i32) (result i32)
        get_local 0
        i32.load16_s)
      (func (;7;) (type 0) (param i32) (result i32)
        get_local 0
        i32.load16_u)
      (func (;8;) (type 1) (param i32) (result i64)
        get_local 0
        i64.load8_s)
      (func (;9;) (type 1) (param i32) (result i64)
        get_local 0
        i64.load8_u)
      (func (;10;) (type 1) (param i32) (result i64)
        get_local 0
        i64.load16_s)
      (func (;11;) (type 1) (param i32) (result i64)
        get_local 0
        i64.load16_u)
      (func (;12;) (type 1) (param i32) (result i64)
        get_local 0
        i64.load32_s)
      (func (;13;) (type 1) (param i32) (result i64)
        get_local 0
        i64.load32_u)
      (func (;14;) (type 4) (param i32 i32)
        get_local 0
        get_local 1
        i32.store)
      (func (;15;) (type 5) (param i32 i64)
        get_local 0
        get_local 1
        i64.store)
      (func (;16;) (type 6) (param i32 f32)
        get_local 0
        get_local 1
        f32.store)
      (func (;17;) (type 7) (param i32 f64)
        get_local 0
        get_local 1
        f64.store)
      (func (;18;) (type 4) (param i32 i32)
        get_local 0
        get_local 1
        i32.store8)
      (func (;19;) (type 4) (param i32 i32)
        get_local 0
        get_local 1
        i32.store16)
      (func (;20;) (type 5) (param i32 i64)
        get_local 0
        get_local 1
        i64.store8)
      (func (;21;) (type 5) (param i32 i64)
        get_local 0
        get_local 1
        i64.store16)
      (func (;22;) (type 5) (param i32 i64)
        get_local 0
        get_local 1
        i64.store32)
      (memory (;0;) 1)
      (export \"i32.load\" (func 0))
      (export \"i64.load\" (func 1))
      (export \"f32.load\" (func 2))
      (export \"f64.load\" (func 3))
      (export \"i32.load8_s\" (func 4))
      (export \"i32.load8_u\" (func 5))
      (export \"i32.load16_s\" (func 6))
      (export \"i32.load16_u\" (func 7))
      (export \"i64.load8_s\" (func 8))
      (export \"i64.load8_u\" (func 9))
      (export \"i64.load16_s\" (func 10))
      (export \"i64.load16_u\" (func 11))
      (export \"i64.load32_s\" (func 12))
      (export \"i64.load32_u\" (func 13))
      (export \"i32.store\" (func 14))
      (export \"i64.store\" (func 15))
      (export \"f32.store\" (func 16))
      (export \"f64.store\" (func 17))
      (export \"i32.store8\" (func 18))
      (export \"i32.store16\" (func 19))
      (export \"i64.store8\" (func 20))
      (export \"i64.store16\" (func 21))
      (export \"i64.store32\" (func 22))
      (data (;0;) (i32.const 0) \"abcdefgh\")
      (data (;1;) (i32.const 65528) \"abcdefgh\"))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
    module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
}

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

// Line 111
fn c15_l111_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c15_l111_action_invoke");
    let result = instance.call("i32.store", &[Value::I32(65536 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c15_l111_assert_trap() {
    let mut instance = create_module_2();
    let result = c15_l111_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 112
fn c16_l112_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c16_l112_action_invoke");
    let result = instance.call("i32.store", &[Value::I32(65535 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c16_l112_assert_trap() {
    let mut instance = create_module_2();
    let result = c16_l112_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 113
fn c17_l113_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c17_l113_action_invoke");
    let result = instance.call("i32.store", &[Value::I32(65534 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c17_l113_assert_trap() {
    let mut instance = create_module_2();
    let result = c17_l113_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 114
fn c18_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c18_l114_action_invoke");
    let result = instance.call("i32.store", &[Value::I32(65533 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c18_l114_assert_trap() {
    let mut instance = create_module_2();
    let result = c18_l114_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 115
fn c19_l115_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c19_l115_action_invoke");
    let result = instance.call("i32.store", &[Value::I32(-1 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c19_l115_assert_trap() {
    let mut instance = create_module_2();
    let result = c19_l115_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 116
fn c20_l116_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c20_l116_action_invoke");
    let result = instance.call("i32.store", &[Value::I32(-2 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c20_l116_assert_trap() {
    let mut instance = create_module_2();
    let result = c20_l116_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 117
fn c21_l117_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c21_l117_action_invoke");
    let result = instance.call("i32.store", &[Value::I32(-3 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c21_l117_assert_trap() {
    let mut instance = create_module_2();
    let result = c21_l117_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 118
fn c22_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c22_l118_action_invoke");
    let result = instance.call("i32.store", &[Value::I32(-4 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c22_l118_assert_trap() {
    let mut instance = create_module_2();
    let result = c22_l118_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c23_l119_assert_trap() {
    let mut instance = create_module_2();
    let result = c23_l119_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c24_l120_assert_trap() {
    let mut instance = create_module_2();
    let result = c24_l120_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c25_l121_assert_trap() {
    let mut instance = create_module_2();
    let result = c25_l121_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c26_l122_assert_trap() {
    let mut instance = create_module_2();
    let result = c26_l122_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c27_l123_assert_trap() {
    let mut instance = create_module_2();
    let result = c27_l123_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c28_l124_assert_trap() {
    let mut instance = create_module_2();
    let result = c28_l124_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c29_l125_assert_trap() {
    let mut instance = create_module_2();
    let result = c29_l125_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c30_l126_assert_trap() {
    let mut instance = create_module_2();
    let result = c30_l126_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c31_l127_assert_trap() {
    let mut instance = create_module_2();
    let result = c31_l127_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c32_l128_assert_trap() {
    let mut instance = create_module_2();
    let result = c32_l128_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c33_l129_assert_trap() {
    let mut instance = create_module_2();
    let result = c33_l129_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c34_l130_assert_trap() {
    let mut instance = create_module_2();
    let result = c34_l130_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c35_l131_assert_trap() {
    let mut instance = create_module_2();
    let result = c35_l131_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c36_l132_assert_trap() {
    let mut instance = create_module_2();
    let result = c36_l132_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c37_l133_assert_trap() {
    let mut instance = create_module_2();
    let result = c37_l133_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c38_l134_assert_trap() {
    let mut instance = create_module_2();
    let result = c38_l134_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 135
fn c39_l135_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c39_l135_action_invoke");
    let result = instance.call("f32.store", &[Value::I32(65536 as i32), Value::F32((0.0f32))]);
    
    result.map(|_| ())
}

#[test]
fn c39_l135_assert_trap() {
    let mut instance = create_module_2();
    let result = c39_l135_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 136
fn c40_l136_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c40_l136_action_invoke");
    let result = instance.call("f32.store", &[Value::I32(65535 as i32), Value::F32((0.0f32))]);
    
    result.map(|_| ())
}

#[test]
fn c40_l136_assert_trap() {
    let mut instance = create_module_2();
    let result = c40_l136_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 137
fn c41_l137_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c41_l137_action_invoke");
    let result = instance.call("f32.store", &[Value::I32(65534 as i32), Value::F32((0.0f32))]);
    
    result.map(|_| ())
}

#[test]
fn c41_l137_assert_trap() {
    let mut instance = create_module_2();
    let result = c41_l137_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 138
fn c42_l138_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c42_l138_action_invoke");
    let result = instance.call("f32.store", &[Value::I32(65533 as i32), Value::F32((0.0f32))]);
    
    result.map(|_| ())
}

#[test]
fn c42_l138_assert_trap() {
    let mut instance = create_module_2();
    let result = c42_l138_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 139
fn c43_l139_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c43_l139_action_invoke");
    let result = instance.call("f32.store", &[Value::I32(-1 as i32), Value::F32((0.0f32))]);
    
    result.map(|_| ())
}

#[test]
fn c43_l139_assert_trap() {
    let mut instance = create_module_2();
    let result = c43_l139_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 140
fn c44_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c44_l140_action_invoke");
    let result = instance.call("f32.store", &[Value::I32(-2 as i32), Value::F32((0.0f32))]);
    
    result.map(|_| ())
}

#[test]
fn c44_l140_assert_trap() {
    let mut instance = create_module_2();
    let result = c44_l140_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 141
fn c45_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c45_l141_action_invoke");
    let result = instance.call("f32.store", &[Value::I32(-3 as i32), Value::F32((0.0f32))]);
    
    result.map(|_| ())
}

#[test]
fn c45_l141_assert_trap() {
    let mut instance = create_module_2();
    let result = c45_l141_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 142
fn c46_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c46_l142_action_invoke");
    let result = instance.call("f32.store", &[Value::I32(-4 as i32), Value::F32((0.0f32))]);
    
    result.map(|_| ())
}

#[test]
fn c46_l142_assert_trap() {
    let mut instance = create_module_2();
    let result = c46_l142_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 143
fn c47_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c47_l143_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(65536 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c47_l143_assert_trap() {
    let mut instance = create_module_2();
    let result = c47_l143_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 144
fn c48_l144_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c48_l144_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(65535 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c48_l144_assert_trap() {
    let mut instance = create_module_2();
    let result = c48_l144_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c49_l145_assert_trap() {
    let mut instance = create_module_2();
    let result = c49_l145_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c50_l146_assert_trap() {
    let mut instance = create_module_2();
    let result = c50_l146_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c51_l147_assert_trap() {
    let mut instance = create_module_2();
    let result = c51_l147_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c52_l148_assert_trap() {
    let mut instance = create_module_2();
    let result = c52_l148_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 149
fn c53_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c53_l149_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(65530 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c53_l149_assert_trap() {
    let mut instance = create_module_2();
    let result = c53_l149_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 150
fn c54_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c54_l150_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(65529 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c54_l150_assert_trap() {
    let mut instance = create_module_2();
    let result = c54_l150_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 151
fn c55_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c55_l151_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(-1 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c55_l151_assert_trap() {
    let mut instance = create_module_2();
    let result = c55_l151_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 152
fn c56_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c56_l152_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(-2 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c56_l152_assert_trap() {
    let mut instance = create_module_2();
    let result = c56_l152_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 153
fn c57_l153_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c57_l153_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(-3 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c57_l153_assert_trap() {
    let mut instance = create_module_2();
    let result = c57_l153_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 154
fn c58_l154_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c58_l154_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(-4 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c58_l154_assert_trap() {
    let mut instance = create_module_2();
    let result = c58_l154_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 155
fn c59_l155_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c59_l155_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(-5 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c59_l155_assert_trap() {
    let mut instance = create_module_2();
    let result = c59_l155_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 156
fn c60_l156_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c60_l156_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(-6 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c60_l156_assert_trap() {
    let mut instance = create_module_2();
    let result = c60_l156_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 157
fn c61_l157_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c61_l157_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(-7 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c61_l157_assert_trap() {
    let mut instance = create_module_2();
    let result = c61_l157_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 158
fn c62_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c62_l158_action_invoke");
    let result = instance.call("f64.store", &[Value::I32(-8 as i32), Value::F64((0.0f64))]);
    
    result.map(|_| ())
}

#[test]
fn c62_l158_assert_trap() {
    let mut instance = create_module_2();
    let result = c62_l158_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 159
fn c63_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c63_l159_action_invoke");
    let result = instance.call("i32.store8", &[Value::I32(65536 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c63_l159_assert_trap() {
    let mut instance = create_module_2();
    let result = c63_l159_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 160
fn c64_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c64_l160_action_invoke");
    let result = instance.call("i32.store8", &[Value::I32(-1 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c64_l160_assert_trap() {
    let mut instance = create_module_2();
    let result = c64_l160_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 161
fn c65_l161_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c65_l161_action_invoke");
    let result = instance.call("i32.store16", &[Value::I32(65536 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c65_l161_assert_trap() {
    let mut instance = create_module_2();
    let result = c65_l161_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 162
fn c66_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c66_l162_action_invoke");
    let result = instance.call("i32.store16", &[Value::I32(65535 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c66_l162_assert_trap() {
    let mut instance = create_module_2();
    let result = c66_l162_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 163
fn c67_l163_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c67_l163_action_invoke");
    let result = instance.call("i32.store16", &[Value::I32(-1 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c67_l163_assert_trap() {
    let mut instance = create_module_2();
    let result = c67_l163_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 164
fn c68_l164_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c68_l164_action_invoke");
    let result = instance.call("i32.store16", &[Value::I32(-2 as i32), Value::I32(0 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c68_l164_assert_trap() {
    let mut instance = create_module_2();
    let result = c68_l164_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c69_l165_assert_trap() {
    let mut instance = create_module_2();
    let result = c69_l165_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c70_l166_assert_trap() {
    let mut instance = create_module_2();
    let result = c70_l166_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c71_l167_assert_trap() {
    let mut instance = create_module_2();
    let result = c71_l167_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c72_l168_assert_trap() {
    let mut instance = create_module_2();
    let result = c72_l168_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c73_l169_assert_trap() {
    let mut instance = create_module_2();
    let result = c73_l169_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c74_l170_assert_trap() {
    let mut instance = create_module_2();
    let result = c74_l170_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c75_l171_assert_trap() {
    let mut instance = create_module_2();
    let result = c75_l171_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c76_l172_assert_trap() {
    let mut instance = create_module_2();
    let result = c76_l172_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c77_l173_assert_trap() {
    let mut instance = create_module_2();
    let result = c77_l173_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c78_l174_assert_trap() {
    let mut instance = create_module_2();
    let result = c78_l174_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c79_l175_assert_trap() {
    let mut instance = create_module_2();
    let result = c79_l175_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c80_l176_assert_trap() {
    let mut instance = create_module_2();
    let result = c80_l176_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c81_l177_assert_trap() {
    let mut instance = create_module_2();
    let result = c81_l177_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c82_l178_assert_trap() {
    let mut instance = create_module_2();
    let result = c82_l178_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 179
fn c83_l179_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c83_l179_action_invoke");
    let result = instance.call("i32.load", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c83_l179_assert_trap() {
    let mut instance = create_module_2();
    let result = c83_l179_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 180
fn c84_l180_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c84_l180_action_invoke");
    let result = instance.call("i32.load", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c84_l180_assert_trap() {
    let mut instance = create_module_2();
    let result = c84_l180_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 181
fn c85_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c85_l181_action_invoke");
    let result = instance.call("i32.load", &[Value::I32(65534 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c85_l181_assert_trap() {
    let mut instance = create_module_2();
    let result = c85_l181_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 182
fn c86_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c86_l182_action_invoke");
    let result = instance.call("i32.load", &[Value::I32(65533 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c86_l182_assert_trap() {
    let mut instance = create_module_2();
    let result = c86_l182_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 183
fn c87_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c87_l183_action_invoke");
    let result = instance.call("i32.load", &[Value::I32(-1 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c87_l183_assert_trap() {
    let mut instance = create_module_2();
    let result = c87_l183_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 184
fn c88_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c88_l184_action_invoke");
    let result = instance.call("i32.load", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c88_l184_assert_trap() {
    let mut instance = create_module_2();
    let result = c88_l184_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 185
fn c89_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c89_l185_action_invoke");
    let result = instance.call("i32.load", &[Value::I32(-3 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c89_l185_assert_trap() {
    let mut instance = create_module_2();
    let result = c89_l185_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 186
fn c90_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c90_l186_action_invoke");
    let result = instance.call("i32.load", &[Value::I32(-4 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c90_l186_assert_trap() {
    let mut instance = create_module_2();
    let result = c90_l186_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 187
fn c91_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c91_l187_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c91_l187_assert_trap() {
    let mut instance = create_module_2();
    let result = c91_l187_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 188
fn c92_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c92_l188_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c92_l188_assert_trap() {
    let mut instance = create_module_2();
    let result = c92_l188_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 189
fn c93_l189_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c93_l189_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(65534 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c93_l189_assert_trap() {
    let mut instance = create_module_2();
    let result = c93_l189_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 190
fn c94_l190_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c94_l190_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(65533 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c94_l190_assert_trap() {
    let mut instance = create_module_2();
    let result = c94_l190_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 191
fn c95_l191_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c95_l191_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(65532 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c95_l191_assert_trap() {
    let mut instance = create_module_2();
    let result = c95_l191_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 192
fn c96_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c96_l192_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(65531 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c96_l192_assert_trap() {
    let mut instance = create_module_2();
    let result = c96_l192_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 193
fn c97_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c97_l193_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(65530 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c97_l193_assert_trap() {
    let mut instance = create_module_2();
    let result = c97_l193_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 194
fn c98_l194_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c98_l194_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(65529 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c98_l194_assert_trap() {
    let mut instance = create_module_2();
    let result = c98_l194_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c99_l195_assert_trap() {
    let mut instance = create_module_2();
    let result = c99_l195_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 196
fn c100_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c100_l196_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c100_l196_assert_trap() {
    let mut instance = create_module_2();
    let result = c100_l196_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 197
fn c101_l197_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c101_l197_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(-3 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c101_l197_assert_trap() {
    let mut instance = create_module_2();
    let result = c101_l197_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 198
fn c102_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c102_l198_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(-4 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c102_l198_assert_trap() {
    let mut instance = create_module_2();
    let result = c102_l198_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 199
fn c103_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c103_l199_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(-5 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c103_l199_assert_trap() {
    let mut instance = create_module_2();
    let result = c103_l199_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 200
fn c104_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c104_l200_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(-6 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c104_l200_assert_trap() {
    let mut instance = create_module_2();
    let result = c104_l200_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 201
fn c105_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c105_l201_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(-7 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c105_l201_assert_trap() {
    let mut instance = create_module_2();
    let result = c105_l201_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 202
fn c106_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c106_l202_action_invoke");
    let result = instance.call("i64.load", &[Value::I32(-8 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c106_l202_assert_trap() {
    let mut instance = create_module_2();
    let result = c106_l202_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 203
fn c107_l203_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c107_l203_action_invoke");
    let result = instance.call("f32.load", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c107_l203_assert_trap() {
    let mut instance = create_module_2();
    let result = c107_l203_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 204
fn c108_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c108_l204_action_invoke");
    let result = instance.call("f32.load", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c108_l204_assert_trap() {
    let mut instance = create_module_2();
    let result = c108_l204_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 205
fn c109_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c109_l205_action_invoke");
    let result = instance.call("f32.load", &[Value::I32(65534 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c109_l205_assert_trap() {
    let mut instance = create_module_2();
    let result = c109_l205_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 206
fn c110_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c110_l206_action_invoke");
    let result = instance.call("f32.load", &[Value::I32(65533 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c110_l206_assert_trap() {
    let mut instance = create_module_2();
    let result = c110_l206_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 207
fn c111_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c111_l207_action_invoke");
    let result = instance.call("f32.load", &[Value::I32(-1 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c111_l207_assert_trap() {
    let mut instance = create_module_2();
    let result = c111_l207_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 208
fn c112_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c112_l208_action_invoke");
    let result = instance.call("f32.load", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c112_l208_assert_trap() {
    let mut instance = create_module_2();
    let result = c112_l208_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 209
fn c113_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c113_l209_action_invoke");
    let result = instance.call("f32.load", &[Value::I32(-3 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c113_l209_assert_trap() {
    let mut instance = create_module_2();
    let result = c113_l209_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 210
fn c114_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c114_l210_action_invoke");
    let result = instance.call("f32.load", &[Value::I32(-4 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c114_l210_assert_trap() {
    let mut instance = create_module_2();
    let result = c114_l210_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 211
fn c115_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c115_l211_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c115_l211_assert_trap() {
    let mut instance = create_module_2();
    let result = c115_l211_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 212
fn c116_l212_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c116_l212_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c116_l212_assert_trap() {
    let mut instance = create_module_2();
    let result = c116_l212_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 213
fn c117_l213_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c117_l213_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(65534 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c117_l213_assert_trap() {
    let mut instance = create_module_2();
    let result = c117_l213_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 214
fn c118_l214_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c118_l214_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(65533 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c118_l214_assert_trap() {
    let mut instance = create_module_2();
    let result = c118_l214_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 215
fn c119_l215_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c119_l215_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(65532 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c119_l215_assert_trap() {
    let mut instance = create_module_2();
    let result = c119_l215_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 216
fn c120_l216_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c120_l216_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(65531 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c120_l216_assert_trap() {
    let mut instance = create_module_2();
    let result = c120_l216_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 217
fn c121_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c121_l217_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(65530 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c121_l217_assert_trap() {
    let mut instance = create_module_2();
    let result = c121_l217_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 218
fn c122_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c122_l218_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(65529 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c122_l218_assert_trap() {
    let mut instance = create_module_2();
    let result = c122_l218_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 219
fn c123_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c123_l219_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(-1 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c123_l219_assert_trap() {
    let mut instance = create_module_2();
    let result = c123_l219_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 220
fn c124_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c124_l220_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c124_l220_assert_trap() {
    let mut instance = create_module_2();
    let result = c124_l220_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 221
fn c125_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c125_l221_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(-3 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c125_l221_assert_trap() {
    let mut instance = create_module_2();
    let result = c125_l221_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 222
fn c126_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c126_l222_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(-4 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c126_l222_assert_trap() {
    let mut instance = create_module_2();
    let result = c126_l222_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 223
fn c127_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c127_l223_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(-5 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c127_l223_assert_trap() {
    let mut instance = create_module_2();
    let result = c127_l223_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 224
fn c128_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c128_l224_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(-6 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c128_l224_assert_trap() {
    let mut instance = create_module_2();
    let result = c128_l224_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 225
fn c129_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c129_l225_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(-7 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c129_l225_assert_trap() {
    let mut instance = create_module_2();
    let result = c129_l225_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 226
fn c130_l226_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c130_l226_action_invoke");
    let result = instance.call("f64.load", &[Value::I32(-8 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c130_l226_assert_trap() {
    let mut instance = create_module_2();
    let result = c130_l226_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 227
fn c131_l227_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c131_l227_action_invoke");
    let result = instance.call("i32.load8_s", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c131_l227_assert_trap() {
    let mut instance = create_module_2();
    let result = c131_l227_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 228
fn c132_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c132_l228_action_invoke");
    let result = instance.call("i32.load8_s", &[Value::I32(-1 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c132_l228_assert_trap() {
    let mut instance = create_module_2();
    let result = c132_l228_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 229
fn c133_l229_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c133_l229_action_invoke");
    let result = instance.call("i32.load8_u", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c133_l229_assert_trap() {
    let mut instance = create_module_2();
    let result = c133_l229_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 230
fn c134_l230_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c134_l230_action_invoke");
    let result = instance.call("i32.load8_u", &[Value::I32(-1 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c134_l230_assert_trap() {
    let mut instance = create_module_2();
    let result = c134_l230_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 231
fn c135_l231_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c135_l231_action_invoke");
    let result = instance.call("i32.load16_s", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c135_l231_assert_trap() {
    let mut instance = create_module_2();
    let result = c135_l231_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 232
fn c136_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c136_l232_action_invoke");
    let result = instance.call("i32.load16_s", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c136_l232_assert_trap() {
    let mut instance = create_module_2();
    let result = c136_l232_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 233
fn c137_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c137_l233_action_invoke");
    let result = instance.call("i32.load16_s", &[Value::I32(-1 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c137_l233_assert_trap() {
    let mut instance = create_module_2();
    let result = c137_l233_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 234
fn c138_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c138_l234_action_invoke");
    let result = instance.call("i32.load16_s", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c138_l234_assert_trap() {
    let mut instance = create_module_2();
    let result = c138_l234_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 235
fn c139_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c139_l235_action_invoke");
    let result = instance.call("i32.load16_u", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c139_l235_assert_trap() {
    let mut instance = create_module_2();
    let result = c139_l235_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 236
fn c140_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c140_l236_action_invoke");
    let result = instance.call("i32.load16_u", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c140_l236_assert_trap() {
    let mut instance = create_module_2();
    let result = c140_l236_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 237
fn c141_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c141_l237_action_invoke");
    let result = instance.call("i32.load16_u", &[Value::I32(-1 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c141_l237_assert_trap() {
    let mut instance = create_module_2();
    let result = c141_l237_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 238
fn c142_l238_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c142_l238_action_invoke");
    let result = instance.call("i32.load16_u", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c142_l238_assert_trap() {
    let mut instance = create_module_2();
    let result = c142_l238_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 239
fn c143_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c143_l239_action_invoke");
    let result = instance.call("i64.load8_s", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c143_l239_assert_trap() {
    let mut instance = create_module_2();
    let result = c143_l239_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c144_l240_assert_trap() {
    let mut instance = create_module_2();
    let result = c144_l240_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 241
fn c145_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c145_l241_action_invoke");
    let result = instance.call("i64.load8_u", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c145_l241_assert_trap() {
    let mut instance = create_module_2();
    let result = c145_l241_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c146_l242_assert_trap() {
    let mut instance = create_module_2();
    let result = c146_l242_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 243
fn c147_l243_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c147_l243_action_invoke");
    let result = instance.call("i64.load16_s", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c147_l243_assert_trap() {
    let mut instance = create_module_2();
    let result = c147_l243_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 244
fn c148_l244_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c148_l244_action_invoke");
    let result = instance.call("i64.load16_s", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c148_l244_assert_trap() {
    let mut instance = create_module_2();
    let result = c148_l244_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c149_l245_assert_trap() {
    let mut instance = create_module_2();
    let result = c149_l245_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 246
fn c150_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c150_l246_action_invoke");
    let result = instance.call("i64.load16_s", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c150_l246_assert_trap() {
    let mut instance = create_module_2();
    let result = c150_l246_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 247
fn c151_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c151_l247_action_invoke");
    let result = instance.call("i64.load16_u", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c151_l247_assert_trap() {
    let mut instance = create_module_2();
    let result = c151_l247_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 248
fn c152_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c152_l248_action_invoke");
    let result = instance.call("i64.load16_u", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c152_l248_assert_trap() {
    let mut instance = create_module_2();
    let result = c152_l248_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c153_l249_assert_trap() {
    let mut instance = create_module_2();
    let result = c153_l249_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 250
fn c154_l250_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c154_l250_action_invoke");
    let result = instance.call("i64.load16_u", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c154_l250_assert_trap() {
    let mut instance = create_module_2();
    let result = c154_l250_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 251
fn c155_l251_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c155_l251_action_invoke");
    let result = instance.call("i64.load32_s", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c155_l251_assert_trap() {
    let mut instance = create_module_2();
    let result = c155_l251_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 252
fn c156_l252_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c156_l252_action_invoke");
    let result = instance.call("i64.load32_s", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c156_l252_assert_trap() {
    let mut instance = create_module_2();
    let result = c156_l252_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 253
fn c157_l253_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c157_l253_action_invoke");
    let result = instance.call("i64.load32_s", &[Value::I32(65534 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c157_l253_assert_trap() {
    let mut instance = create_module_2();
    let result = c157_l253_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 254
fn c158_l254_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c158_l254_action_invoke");
    let result = instance.call("i64.load32_s", &[Value::I32(65533 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c158_l254_assert_trap() {
    let mut instance = create_module_2();
    let result = c158_l254_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c159_l255_assert_trap() {
    let mut instance = create_module_2();
    let result = c159_l255_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 256
fn c160_l256_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c160_l256_action_invoke");
    let result = instance.call("i64.load32_s", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c160_l256_assert_trap() {
    let mut instance = create_module_2();
    let result = c160_l256_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 257
fn c161_l257_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c161_l257_action_invoke");
    let result = instance.call("i64.load32_s", &[Value::I32(-3 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c161_l257_assert_trap() {
    let mut instance = create_module_2();
    let result = c161_l257_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 258
fn c162_l258_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c162_l258_action_invoke");
    let result = instance.call("i64.load32_s", &[Value::I32(-4 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c162_l258_assert_trap() {
    let mut instance = create_module_2();
    let result = c162_l258_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 259
fn c163_l259_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c163_l259_action_invoke");
    let result = instance.call("i64.load32_u", &[Value::I32(65536 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c163_l259_assert_trap() {
    let mut instance = create_module_2();
    let result = c163_l259_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 260
fn c164_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c164_l260_action_invoke");
    let result = instance.call("i64.load32_u", &[Value::I32(65535 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c164_l260_assert_trap() {
    let mut instance = create_module_2();
    let result = c164_l260_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 261
fn c165_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c165_l261_action_invoke");
    let result = instance.call("i64.load32_u", &[Value::I32(65534 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c165_l261_assert_trap() {
    let mut instance = create_module_2();
    let result = c165_l261_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 262
fn c166_l262_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c166_l262_action_invoke");
    let result = instance.call("i64.load32_u", &[Value::I32(65533 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c166_l262_assert_trap() {
    let mut instance = create_module_2();
    let result = c166_l262_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

#[test]
fn c167_l263_assert_trap() {
    let mut instance = create_module_2();
    let result = c167_l263_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 264
fn c168_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c168_l264_action_invoke");
    let result = instance.call("i64.load32_u", &[Value::I32(-2 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c168_l264_assert_trap() {
    let mut instance = create_module_2();
    let result = c168_l264_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 265
fn c169_l265_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c169_l265_action_invoke");
    let result = instance.call("i64.load32_u", &[Value::I32(-3 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c169_l265_assert_trap() {
    let mut instance = create_module_2();
    let result = c169_l265_action_invoke(&mut*instance);
    assert!(result.is_err());
}

// Line 266
fn c170_l266_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c170_l266_action_invoke");
    let result = instance.call("i64.load32_u", &[Value::I32(-4 as i32)]);
    
    result.map(|_| ())
}

#[test]
fn c170_l266_assert_trap() {
    let mut instance = create_module_2();
    let result = c170_l266_action_invoke(&mut*instance);
    assert!(result.is_err());
}

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

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

#[test]
fn test_module_2() {
    let mut instance = create_module_2();
    // We group the calls together
    start_module_2(&mut instance);
    c171_l269_action_invoke(&mut instance);
    c172_l270_action_invoke(&mut instance);
}