wasmer/lib/runtime/tests/spectests/memory_trap.rs

// 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 std::{f32, f64};
use wabt::wat2wasm;

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

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

// Line 1
fn create_module_1() -> 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(&generate_imports())
        .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() -> 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(&generate_imports())
        .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);
}