// Rust test file autogenerated with cargo build (src/build_spectests.rs).
// Please do NOT modify it by hand, as it will be reseted on next build.
// Test based on spectests/int_exprs.wast
#![allow(
    warnings,
    dead_code
)]
use std::panic;
use wabt::wat2wasm;

use crate::webassembly::{instantiate, compile, ImportObject, ResultObject, Instance, Export};
use super::_common::{
    spectest_importobject,
    NaNCheck,
};


// Line 6
fn create_module_1() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32 i32) (result i32)))
      (type (;1;) (func (param i64 i64) (result i32)))
      (func (;0;) (type 0) (param i32 i32) (result i32)
        get_local 0
        i32.const 1
        i32.add
        get_local 1
        i32.const 1
        i32.add
        i32.lt_s)
      (func (;1;) (type 0) (param i32 i32) (result i32)
        get_local 0
        i32.const 1
        i32.add
        get_local 1
        i32.const 1
        i32.add
        i32.lt_u)
      (func (;2;) (type 1) (param i64 i64) (result i32)
        get_local 0
        i64.const 1
        i64.add
        get_local 1
        i64.const 1
        i64.add
        i64.lt_s)
      (func (;3;) (type 1) (param i64 i64) (result i32)
        get_local 0
        i64.const 1
        i64.add
        get_local 1
        i64.const 1
        i64.add
        i64.lt_u)
      (export \"i32.no_fold_cmp_s_offset\" (func 0))
      (export \"i32.no_fold_cmp_u_offset\" (func 1))
      (export \"i64.no_fold_cmp_s_offset\" (func 2))
      (export \"i64.no_fold_cmp_u_offset\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_1(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 18
fn c1_l18_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c1_l18_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_cmp_s_offset") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(2147483647 as i32, 0 as i32, &result_object.instance);
    assert_eq!(result, 1 as i32);
}

// Line 19
fn c2_l19_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c2_l19_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_cmp_u_offset") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-1 as i32, 0 as i32, &result_object.instance);
    assert_eq!(result, 1 as i32);
}

// Line 20
fn c3_l20_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c3_l20_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_cmp_s_offset") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, i64, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(9223372036854775807 as i64, 0 as i64, &result_object.instance);
    assert_eq!(result, 1 as i32);
}

// Line 21
fn c4_l21_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c4_l21_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_cmp_u_offset") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, i64, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-1 as i64, 0 as i64, &result_object.instance);
    assert_eq!(result, 1 as i32);
}

// Line 25

#[test]
fn test_module_1() {
    let result_object = create_module_1();
    // We group the calls together
    start_module_1(&result_object);
    c1_l18_action_invoke(&result_object);
    c2_l19_action_invoke(&result_object);
    c3_l20_action_invoke(&result_object);
    c4_l21_action_invoke(&result_object);
}
fn create_module_2() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i64) (result i64)
        get_local 0
        i32.wrap/i64
        i64.extend_s/i32)
      (export \"i64.no_fold_wrap_extend_s\" (func 0)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_2(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 30
fn c6_l30_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c6_l30_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_wrap_extend_s") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(4538991236898928 as i64, &result_object.instance);
    assert_eq!(result, 1079009392 as i64);
}

// Line 31
fn c7_l31_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c7_l31_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_wrap_extend_s") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(45230338458316960 as i64, &result_object.instance);
    assert_eq!(result, -790564704 as i64);
}

// Line 35

#[test]
fn test_module_2() {
    let result_object = create_module_2();
    // We group the calls together
    start_module_2(&result_object);
    c6_l30_action_invoke(&result_object);
    c7_l31_action_invoke(&result_object);
}
fn create_module_3() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i64) (result i64)
        get_local 0
        i32.wrap/i64
        i64.extend_u/i32)
      (export \"i64.no_fold_wrap_extend_u\" (func 0)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_3(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 40
fn c9_l40_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c9_l40_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_wrap_extend_u") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(4538991236898928 as i64, &result_object.instance);
    assert_eq!(result, 1079009392 as i64);
}

// Line 44

#[test]
fn test_module_3() {
    let result_object = create_module_3();
    // We group the calls together
    start_module_3(&result_object);
    c9_l40_action_invoke(&result_object);
}
fn create_module_4() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 1
        i32.shl
        i32.const 1
        i32.shr_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 1
        i32.shl
        i32.const 1
        i32.shr_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 1
        i64.shl
        i64.const 1
        i64.shr_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 1
        i64.shl
        i64.const 1
        i64.shr_u)
      (export \"i32.no_fold_shl_shr_s\" (func 0))
      (export \"i32.no_fold_shl_shr_u\" (func 1))
      (export \"i64.no_fold_shl_shr_s\" (func 2))
      (export \"i64.no_fold_shl_shr_u\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_4(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 56
fn c11_l56_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c11_l56_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_shl_shr_s") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-2147483648 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 57
fn c12_l57_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c12_l57_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_shl_shr_u") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-2147483648 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 58
fn c13_l58_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c13_l58_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_shl_shr_s") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-9223372036854775808 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 59
fn c14_l59_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c14_l59_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_shl_shr_u") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-9223372036854775808 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 63

#[test]
fn test_module_4() {
    let result_object = create_module_4();
    // We group the calls together
    start_module_4(&result_object);
    c11_l56_action_invoke(&result_object);
    c12_l57_action_invoke(&result_object);
    c13_l58_action_invoke(&result_object);
    c14_l59_action_invoke(&result_object);
}
fn create_module_5() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 1
        i32.shr_s
        i32.const 1
        i32.shl)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 1
        i32.shr_u
        i32.const 1
        i32.shl)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 1
        i64.shr_s
        i64.const 1
        i64.shl)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 1
        i64.shr_u
        i64.const 1
        i64.shl)
      (export \"i32.no_fold_shr_s_shl\" (func 0))
      (export \"i32.no_fold_shr_u_shl\" (func 1))
      (export \"i64.no_fold_shr_s_shl\" (func 2))
      (export \"i64.no_fold_shr_u_shl\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_5(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 75
fn c16_l75_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c16_l75_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_shr_s_shl") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 76
fn c17_l76_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c17_l76_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_shr_u_shl") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 77
fn c18_l77_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c18_l77_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_shr_s_shl") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 78
fn c19_l78_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c19_l78_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_shr_u_shl") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 82

#[test]
fn test_module_5() {
    let result_object = create_module_5();
    // We group the calls together
    start_module_5(&result_object);
    c16_l75_action_invoke(&result_object);
    c17_l76_action_invoke(&result_object);
    c18_l77_action_invoke(&result_object);
    c19_l78_action_invoke(&result_object);
}
fn create_module_6() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 6
        i32.div_s
        i32.const 6
        i32.mul)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 6
        i32.div_u
        i32.const 6
        i32.mul)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 6
        i64.div_s
        i64.const 6
        i64.mul)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 6
        i64.div_u
        i64.const 6
        i64.mul)
      (export \"i32.no_fold_div_s_mul\" (func 0))
      (export \"i32.no_fold_div_u_mul\" (func 1))
      (export \"i64.no_fold_div_s_mul\" (func 2))
      (export \"i64.no_fold_div_u_mul\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_6(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 94
fn c21_l94_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c21_l94_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_div_s_mul") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 95
fn c22_l95_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c22_l95_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_div_u_mul") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 96
fn c23_l96_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c23_l96_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_div_s_mul") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 97
fn c24_l97_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c24_l97_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_div_u_mul") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 101

#[test]
fn test_module_6() {
    let result_object = create_module_6();
    // We group the calls together
    start_module_6(&result_object);
    c21_l94_action_invoke(&result_object);
    c22_l95_action_invoke(&result_object);
    c23_l96_action_invoke(&result_object);
    c24_l97_action_invoke(&result_object);
}
fn create_module_7() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        get_local 0
        i32.div_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        get_local 0
        i32.div_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        get_local 0
        i64.div_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        get_local 0
        i64.div_u)
      (export \"i32.no_fold_div_s_self\" (func 0))
      (export \"i32.no_fold_div_u_self\" (func 1))
      (export \"i64.no_fold_div_s_self\" (func 2))
      (export \"i64.no_fold_div_u_self\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_7(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 113
fn c26_l113_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c26_l113_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_div_s_self") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(0 as i32, &result_object.instance);
    
}

#[test]
fn c26_l113_assert_trap() {
    let result_object = create_module_7();
    let result = panic::catch_unwind(|| {
        c26_l113_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 114
fn c27_l114_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c27_l114_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_div_u_self") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(0 as i32, &result_object.instance);
    
}

#[test]
fn c27_l114_assert_trap() {
    let result_object = create_module_7();
    let result = panic::catch_unwind(|| {
        c27_l114_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 115
fn c28_l115_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c28_l115_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_div_s_self") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(0 as i64, &result_object.instance);
    
}

#[test]
fn c28_l115_assert_trap() {
    let result_object = create_module_7();
    let result = panic::catch_unwind(|| {
        c28_l115_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 116
fn c29_l116_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c29_l116_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_div_u_self") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(0 as i64, &result_object.instance);
    
}

#[test]
fn c29_l116_assert_trap() {
    let result_object = create_module_7();
    let result = panic::catch_unwind(|| {
        c29_l116_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 120

#[test]
fn test_module_7() {
    let result_object = create_module_7();
    // We group the calls together
    start_module_7(&result_object);
}
fn create_module_8() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        get_local 0
        i32.rem_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        get_local 0
        i32.rem_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        get_local 0
        i64.rem_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        get_local 0
        i64.rem_u)
      (export \"i32.no_fold_rem_s_self\" (func 0))
      (export \"i32.no_fold_rem_u_self\" (func 1))
      (export \"i64.no_fold_rem_s_self\" (func 2))
      (export \"i64.no_fold_rem_u_self\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_8(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 132
fn c31_l132_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c31_l132_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_rem_s_self") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(0 as i32, &result_object.instance);
    
}

#[test]
fn c31_l132_assert_trap() {
    let result_object = create_module_8();
    let result = panic::catch_unwind(|| {
        c31_l132_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 133
fn c32_l133_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c32_l133_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_rem_u_self") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(0 as i32, &result_object.instance);
    
}

#[test]
fn c32_l133_assert_trap() {
    let result_object = create_module_8();
    let result = panic::catch_unwind(|| {
        c32_l133_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 134
fn c33_l134_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c33_l134_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_rem_s_self") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(0 as i64, &result_object.instance);
    
}

#[test]
fn c33_l134_assert_trap() {
    let result_object = create_module_8();
    let result = panic::catch_unwind(|| {
        c33_l134_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 135
fn c34_l135_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c34_l135_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_rem_u_self") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(0 as i64, &result_object.instance);
    
}

#[test]
fn c34_l135_assert_trap() {
    let result_object = create_module_8();
    let result = panic::catch_unwind(|| {
        c34_l135_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 139

#[test]
fn test_module_8() {
    let result_object = create_module_8();
    // We group the calls together
    start_module_8(&result_object);
}
fn create_module_9() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 6
        i32.mul
        i32.const 6
        i32.div_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 6
        i32.mul
        i32.const 6
        i32.div_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 6
        i64.mul
        i64.const 6
        i64.div_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 6
        i64.mul
        i64.const 6
        i64.div_u)
      (export \"i32.no_fold_mul_div_s\" (func 0))
      (export \"i32.no_fold_mul_div_u\" (func 1))
      (export \"i64.no_fold_mul_div_s\" (func 2))
      (export \"i64.no_fold_mul_div_u\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_9(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 151
fn c36_l151_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c36_l151_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_mul_div_s") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-2147483648 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 152
fn c37_l152_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c37_l152_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_mul_div_u") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-2147483648 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 153
fn c38_l153_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c38_l153_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_mul_div_s") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-9223372036854775808 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 154
fn c39_l154_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c39_l154_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_mul_div_u") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-9223372036854775808 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 158

#[test]
fn test_module_9() {
    let result_object = create_module_9();
    // We group the calls together
    start_module_9(&result_object);
    c36_l151_action_invoke(&result_object);
    c37_l152_action_invoke(&result_object);
    c38_l153_action_invoke(&result_object);
    c39_l154_action_invoke(&result_object);
}
fn create_module_10() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 2
        i32.div_s)
      (func (;1;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 2
        i64.div_s)
      (export \"i32.no_fold_div_s_2\" (func 0))
      (export \"i64.no_fold_div_s_2\" (func 1)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_10(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 166
fn c41_l166_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c41_l166_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_div_s_2") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-11 as i32, &result_object.instance);
    assert_eq!(result, -5 as i32);
}

// Line 167
fn c42_l167_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c42_l167_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_div_s_2") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-11 as i64, &result_object.instance);
    assert_eq!(result, -5 as i64);
}

// Line 171

#[test]
fn test_module_10() {
    let result_object = create_module_10();
    // We group the calls together
    start_module_10(&result_object);
    c41_l166_action_invoke(&result_object);
    c42_l167_action_invoke(&result_object);
}
fn create_module_11() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 2
        i32.rem_s)
      (func (;1;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 2
        i64.rem_s)
      (export \"i32.no_fold_rem_s_2\" (func 0))
      (export \"i64.no_fold_rem_s_2\" (func 1)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_11(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 179
fn c44_l179_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c44_l179_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_rem_s_2") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-11 as i32, &result_object.instance);
    assert_eq!(result, -1 as i32);
}

// Line 180
fn c45_l180_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c45_l180_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_rem_s_2") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-11 as i64, &result_object.instance);
    assert_eq!(result, -1 as i64);
}

// Line 184

#[test]
fn test_module_11() {
    let result_object = create_module_11();
    // We group the calls together
    start_module_11(&result_object);
    c44_l179_action_invoke(&result_object);
    c45_l180_action_invoke(&result_object);
}
fn create_module_12() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 0
        i32.div_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 0
        i32.div_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 0
        i64.div_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 0
        i64.div_u)
      (export \"i32.div_s_0\" (func 0))
      (export \"i32.div_u_0\" (func 1))
      (export \"i64.div_s_0\" (func 2))
      (export \"i64.div_u_0\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_12(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 196
fn c47_l196_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c47_l196_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_s_0") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    
}

#[test]
fn c47_l196_assert_trap() {
    let result_object = create_module_12();
    let result = panic::catch_unwind(|| {
        c47_l196_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 197
fn c48_l197_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c48_l197_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_u_0") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    
}

#[test]
fn c48_l197_assert_trap() {
    let result_object = create_module_12();
    let result = panic::catch_unwind(|| {
        c48_l197_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 198
fn c49_l198_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c49_l198_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_s_0") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    
}

#[test]
fn c49_l198_assert_trap() {
    let result_object = create_module_12();
    let result = panic::catch_unwind(|| {
        c49_l198_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 199
fn c50_l199_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c50_l199_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_u_0") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    
}

#[test]
fn c50_l199_assert_trap() {
    let result_object = create_module_12();
    let result = panic::catch_unwind(|| {
        c50_l199_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 203

#[test]
fn test_module_12() {
    let result_object = create_module_12();
    // We group the calls together
    start_module_12(&result_object);
}
fn create_module_13() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 3
        i32.div_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 3
        i32.div_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 3
        i64.div_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 3
        i64.div_u)
      (export \"i32.div_s_3\" (func 0))
      (export \"i32.div_u_3\" (func 1))
      (export \"i64.div_s_3\" (func 2))
      (export \"i64.div_u_3\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_13(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 215
fn c52_l215_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c52_l215_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_s_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 23 as i32);
}

// Line 216
fn c53_l216_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c53_l216_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_s_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1610612736 as i32, &result_object.instance);
    assert_eq!(result, 536870912 as i32);
}

// Line 217
fn c54_l217_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c54_l217_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_u_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 23 as i32);
}

// Line 218
fn c55_l218_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c55_l218_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_u_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-1073741824 as i32, &result_object.instance);
    assert_eq!(result, 1073741824 as i32);
}

// Line 219
fn c56_l219_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c56_l219_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_s_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 23 as i64);
}

// Line 220
fn c57_l220_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c57_l220_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_s_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(3458764513820540928 as i64, &result_object.instance);
    assert_eq!(result, 1152921504606846976 as i64);
}

// Line 221
fn c58_l221_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c58_l221_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_u_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 23 as i64);
}

// Line 222
fn c59_l222_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c59_l222_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_u_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-4611686018427387904 as i64, &result_object.instance);
    assert_eq!(result, 4611686018427387904 as i64);
}

// Line 226

#[test]
fn test_module_13() {
    let result_object = create_module_13();
    // We group the calls together
    start_module_13(&result_object);
    c52_l215_action_invoke(&result_object);
    c53_l216_action_invoke(&result_object);
    c54_l217_action_invoke(&result_object);
    c55_l218_action_invoke(&result_object);
    c56_l219_action_invoke(&result_object);
    c57_l220_action_invoke(&result_object);
    c58_l221_action_invoke(&result_object);
    c59_l222_action_invoke(&result_object);
}
fn create_module_14() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 5
        i32.div_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 5
        i32.div_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 5
        i64.div_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 5
        i64.div_u)
      (export \"i32.div_s_5\" (func 0))
      (export \"i32.div_u_5\" (func 1))
      (export \"i64.div_s_5\" (func 2))
      (export \"i64.div_u_5\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_14(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 238
fn c61_l238_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c61_l238_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_s_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 14 as i32);
}

// Line 239
fn c62_l239_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c62_l239_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_s_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1342177280 as i32, &result_object.instance);
    assert_eq!(result, 268435456 as i32);
}

// Line 240
fn c63_l240_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c63_l240_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_u_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 14 as i32);
}

// Line 241
fn c64_l241_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c64_l241_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_u_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-1610612736 as i32, &result_object.instance);
    assert_eq!(result, 536870912 as i32);
}

// Line 242
fn c65_l242_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c65_l242_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_s_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 14 as i64);
}

// Line 243
fn c66_l243_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c66_l243_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_s_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(5764607523034234880 as i64, &result_object.instance);
    assert_eq!(result, 1152921504606846976 as i64);
}

// Line 244
fn c67_l244_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c67_l244_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_u_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 14 as i64);
}

// Line 245
fn c68_l245_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c68_l245_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_u_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-6917529027641081856 as i64, &result_object.instance);
    assert_eq!(result, 2305843009213693952 as i64);
}

// Line 249

#[test]
fn test_module_14() {
    let result_object = create_module_14();
    // We group the calls together
    start_module_14(&result_object);
    c61_l238_action_invoke(&result_object);
    c62_l239_action_invoke(&result_object);
    c63_l240_action_invoke(&result_object);
    c64_l241_action_invoke(&result_object);
    c65_l242_action_invoke(&result_object);
    c66_l243_action_invoke(&result_object);
    c67_l244_action_invoke(&result_object);
    c68_l245_action_invoke(&result_object);
}
fn create_module_15() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 7
        i32.div_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 7
        i32.div_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 7
        i64.div_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 7
        i64.div_u)
      (export \"i32.div_s_7\" (func 0))
      (export \"i32.div_u_7\" (func 1))
      (export \"i64.div_s_7\" (func 2))
      (export \"i64.div_u_7\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_15(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 261
fn c70_l261_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c70_l261_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_s_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 10 as i32);
}

// Line 262
fn c71_l262_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c71_l262_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_s_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1879048192 as i32, &result_object.instance);
    assert_eq!(result, 268435456 as i32);
}

// Line 263
fn c72_l263_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c72_l263_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_u_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 10 as i32);
}

// Line 264
fn c73_l264_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c73_l264_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.div_u_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-536870912 as i32, &result_object.instance);
    assert_eq!(result, 536870912 as i32);
}

// Line 265
fn c74_l265_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c74_l265_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_s_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 10 as i64);
}

// Line 266
fn c75_l266_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c75_l266_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_s_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(8070450532247928832 as i64, &result_object.instance);
    assert_eq!(result, 1152921504606846976 as i64);
}

// Line 267
fn c76_l267_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c76_l267_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_u_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 10 as i64);
}

// Line 268
fn c77_l268_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c77_l268_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.div_u_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-2305843009213693952 as i64, &result_object.instance);
    assert_eq!(result, 2305843009213693952 as i64);
}

// Line 272

#[test]
fn test_module_15() {
    let result_object = create_module_15();
    // We group the calls together
    start_module_15(&result_object);
    c70_l261_action_invoke(&result_object);
    c71_l262_action_invoke(&result_object);
    c72_l263_action_invoke(&result_object);
    c73_l264_action_invoke(&result_object);
    c74_l265_action_invoke(&result_object);
    c75_l266_action_invoke(&result_object);
    c76_l267_action_invoke(&result_object);
    c77_l268_action_invoke(&result_object);
}
fn create_module_16() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 3
        i32.rem_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 3
        i32.rem_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 3
        i64.rem_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 3
        i64.rem_u)
      (export \"i32.rem_s_3\" (func 0))
      (export \"i32.rem_u_3\" (func 1))
      (export \"i64.rem_s_3\" (func 2))
      (export \"i64.rem_u_3\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_16(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 284
fn c79_l284_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c79_l284_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_s_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 2 as i32);
}

// Line 285
fn c80_l285_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c80_l285_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_s_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1610612736 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 286
fn c81_l286_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c81_l286_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_u_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 2 as i32);
}

// Line 287
fn c82_l287_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c82_l287_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_u_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-1073741824 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 288
fn c83_l288_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c83_l288_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_s_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 2 as i64);
}

// Line 289
fn c84_l289_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c84_l289_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_s_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(3458764513820540928 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 290
fn c85_l290_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c85_l290_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_u_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 2 as i64);
}

// Line 291
fn c86_l291_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c86_l291_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_u_3") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-4611686018427387904 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 295

#[test]
fn test_module_16() {
    let result_object = create_module_16();
    // We group the calls together
    start_module_16(&result_object);
    c79_l284_action_invoke(&result_object);
    c80_l285_action_invoke(&result_object);
    c81_l286_action_invoke(&result_object);
    c82_l287_action_invoke(&result_object);
    c83_l288_action_invoke(&result_object);
    c84_l289_action_invoke(&result_object);
    c85_l290_action_invoke(&result_object);
    c86_l291_action_invoke(&result_object);
}
fn create_module_17() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 5
        i32.rem_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 5
        i32.rem_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 5
        i64.rem_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 5
        i64.rem_u)
      (export \"i32.rem_s_5\" (func 0))
      (export \"i32.rem_u_5\" (func 1))
      (export \"i64.rem_s_5\" (func 2))
      (export \"i64.rem_u_5\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_17(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 307
fn c88_l307_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c88_l307_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_s_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 1 as i32);
}

// Line 308
fn c89_l308_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c89_l308_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_s_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1342177280 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 309
fn c90_l309_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c90_l309_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_u_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 1 as i32);
}

// Line 310
fn c91_l310_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c91_l310_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_u_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-1610612736 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 311
fn c92_l311_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c92_l311_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_s_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 1 as i64);
}

// Line 312
fn c93_l312_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c93_l312_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_s_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(5764607523034234880 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 313
fn c94_l313_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c94_l313_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_u_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 1 as i64);
}

// Line 314
fn c95_l314_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c95_l314_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_u_5") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-6917529027641081856 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 318

#[test]
fn test_module_17() {
    let result_object = create_module_17();
    // We group the calls together
    start_module_17(&result_object);
    c88_l307_action_invoke(&result_object);
    c89_l308_action_invoke(&result_object);
    c90_l309_action_invoke(&result_object);
    c91_l310_action_invoke(&result_object);
    c92_l311_action_invoke(&result_object);
    c93_l312_action_invoke(&result_object);
    c94_l313_action_invoke(&result_object);
    c95_l314_action_invoke(&result_object);
}
fn create_module_18() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 7
        i32.rem_s)
      (func (;1;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 7
        i32.rem_u)
      (func (;2;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 7
        i64.rem_s)
      (func (;3;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const 7
        i64.rem_u)
      (export \"i32.rem_s_7\" (func 0))
      (export \"i32.rem_u_7\" (func 1))
      (export \"i64.rem_s_7\" (func 2))
      (export \"i64.rem_u_7\" (func 3)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_18(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 330
fn c97_l330_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c97_l330_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_s_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 1 as i32);
}

// Line 331
fn c98_l331_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c98_l331_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_s_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(1879048192 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 332
fn c99_l332_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c99_l332_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_u_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i32, &result_object.instance);
    assert_eq!(result, 1 as i32);
}

// Line 333
fn c100_l333_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c100_l333_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.rem_u_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) -> i32 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-536870912 as i32, &result_object.instance);
    assert_eq!(result, 0 as i32);
}

// Line 334
fn c101_l334_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c101_l334_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_s_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 1 as i64);
}

// Line 335
fn c102_l335_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c102_l335_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_s_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(8070450532247928832 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 336
fn c103_l336_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c103_l336_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_u_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(71 as i64, &result_object.instance);
    assert_eq!(result, 1 as i64);
}

// Line 337
fn c104_l337_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c104_l337_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.rem_u_7") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) -> i64 = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-2305843009213693952 as i64, &result_object.instance);
    assert_eq!(result, 0 as i64);
}

// Line 341

#[test]
fn test_module_18() {
    let result_object = create_module_18();
    // We group the calls together
    start_module_18(&result_object);
    c97_l330_action_invoke(&result_object);
    c98_l331_action_invoke(&result_object);
    c99_l332_action_invoke(&result_object);
    c100_l333_action_invoke(&result_object);
    c101_l334_action_invoke(&result_object);
    c102_l335_action_invoke(&result_object);
    c103_l336_action_invoke(&result_object);
    c104_l337_action_invoke(&result_object);
}
fn create_module_19() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (type (;1;) (func (param i64) (result i64)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const -1
        i32.div_s)
      (func (;1;) (type 1) (param i64) (result i64)
        get_local 0
        i64.const -1
        i64.div_s)
      (export \"i32.no_fold_div_neg1\" (func 0))
      (export \"i64.no_fold_div_neg1\" (func 1)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
}

fn start_module_19(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 349
fn c106_l349_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c106_l349_action_invoke");
    let func_index = match result_object.module.info.exports.get("i32.no_fold_div_neg1") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i32, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-2147483648 as i32, &result_object.instance);
    
}

#[test]
fn c106_l349_assert_trap() {
    let result_object = create_module_19();
    let result = panic::catch_unwind(|| {
        c106_l349_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

// Line 350
fn c107_l350_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c107_l350_action_invoke");
    let func_index = match result_object.module.info.exports.get("i64.no_fold_div_neg1") {
        Some(&Export::Function(index)) => index,
        _ => panic!("Function not found"),
    };
    let invoke_fn: fn(i64, &Instance) = get_instance_function!(result_object.instance, func_index);
    let result = invoke_fn(-9223372036854775808 as i64, &result_object.instance);
    
}

#[test]
fn c107_l350_assert_trap() {
    let result_object = create_module_19();
    let result = panic::catch_unwind(|| {
        c107_l350_action_invoke(&result_object);
    });
    assert!(result.is_err());
}

#[test]
fn test_module_19() {
    let result_object = create_module_19();
    // We group the calls together
    start_module_19(&result_object);
}
