// 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/exports.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 3
fn create_module_1() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func))
      (func (;0;) (type 0))
      (export \"a\" (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_1(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 4

#[test]
fn test_module_1() {
    let result_object = create_module_1();
    // We group the calls together
    start_module_1(&result_object);
}
fn create_module_2() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func))
      (func (;0;) (type 0))
      (export \"a\" (func 0))
      (export \"b\" (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 5

#[test]
fn test_module_2() {
    let result_object = create_module_2();
    // We group the calls together
    start_module_2(&result_object);
}
fn create_module_3() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func))
      (func (;0;) (type 0))
      (func (;1;) (type 0))
      (export \"a\" (func 0))
      (export \"b\" (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_3(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 7

#[test]
fn test_module_3() {
    let result_object = create_module_3();
    // We group the calls together
    start_module_3(&result_object);
}
fn create_module_4() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func))
      (func (;0;) (type 0))
      (export \"a\" (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_4(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 8

#[test]
fn test_module_4() {
    let result_object = create_module_4();
    // We group the calls together
    start_module_4(&result_object);
}
fn create_module_5() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func))
      (func (;0;) (type 0))
      (export \"a\" (func 0))
      (export \"b\" (func 0))
      (export \"c\" (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_5(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 9

#[test]
fn test_module_5() {
    let result_object = create_module_5();
    // We group the calls together
    start_module_5(&result_object);
}
fn create_module_6() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32)))
      (func (;0;) (type 0) (param i32))
      (export \"a\" (func 0))
      (export \"b\" (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_6(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 10

#[test]
fn test_module_6() {
    let result_object = create_module_6();
    // We group the calls together
    start_module_6(&result_object);
}
fn create_module_7() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func))
      (func (;0;) (type 0))
      (export \"a\" (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_7(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 11

#[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))
      (func (;0;) (type 0))
      (export \"a\" (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_8(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 12

#[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))
      (func (;0;) (type 0))
      (export \"a\" (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_9(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 13

#[test]
fn test_module_9() {
    let result_object = create_module_9();
    // We group the calls together
    start_module_9(&result_object);
}
fn create_module_10() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func))
      (func (;0;) (type 0))
      (export \"a\" (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_10(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 14

#[test]
fn test_module_10() {
    let result_object = create_module_10();
    // We group the calls together
    start_module_10(&result_object);
}
fn create_module_11() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func))
      (func (;0;) (type 0))
      (export \"a\" (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_11(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 16

#[test]
fn test_module_11() {
    let result_object = create_module_11();
    // We group the calls together
    start_module_11(&result_object);
}
fn create_module_12() -> ResultObject {
    let module_str = "(module
      (type (;0;) (func (param i32) (result i32)))
      (func (;0;) (type 0) (param i32) (result i32)
        get_local 0
        i32.const 1
        i32.add
        return)
      (export \"e\" (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_12(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 22
fn c12_l22_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c12_l22_action_invoke");
    let func_index = match result_object.module.info.exports.get("e") {
        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(42 as i32, &result_object.instance);
    assert_eq!(result, 43 as i32);
}

// Line 23
fn c13_l23_action_invoke(result_object: &ResultObject) {
    println!("Executing function {}", "c13_l23_action_invoke");
    let func_index = match result_object.module.info.exports.get("e") {
        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(42 as i32, &result_object.instance);
    assert_eq!(result, 43 as i32);
}

// Line 29
#[test]
fn c14_l29_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 5, 1, 1, 97, 0, 1, 10, 4, 1, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 33
#[test]
fn c15_l33_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 37
#[test]
fn c16_l37_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, 1, 10, 7, 2, 2, 0, 11, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 41
#[test]
fn c17_l41_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 0, 0, 1, 97, 3, 0, 10, 4, 1, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 45
#[test]
fn c18_l45_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 1, 0, 10, 4, 1, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 49
#[test]
fn c19_l49_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 2, 0, 10, 4, 1, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 56

#[test]
fn test_module_12() {
    let result_object = create_module_12();
    // We group the calls together
    start_module_12(&result_object);
    c12_l22_action_invoke(&result_object);
    c13_l23_action_invoke(&result_object);
}
fn create_module_13() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (export \"a\" (global 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_13(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 57

#[test]
fn test_module_13() {
    let result_object = create_module_13();
    // We group the calls together
    start_module_13(&result_object);
}
fn create_module_14() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (export \"a\" (global 0))
      (export \"b\" (global 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_14(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 58

#[test]
fn test_module_14() {
    let result_object = create_module_14();
    // We group the calls together
    start_module_14(&result_object);
}
fn create_module_15() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (global (;1;) i32 (i32.const 0))
      (export \"a\" (global 0))
      (export \"b\" (global 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_15(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 60

#[test]
fn test_module_15() {
    let result_object = create_module_15();
    // We group the calls together
    start_module_15(&result_object);
}
fn create_module_16() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (export \"a\" (global 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_16(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 61

#[test]
fn test_module_16() {
    let result_object = create_module_16();
    // We group the calls together
    start_module_16(&result_object);
}
fn create_module_17() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (export \"a\" (global 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_17(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 62

#[test]
fn test_module_17() {
    let result_object = create_module_17();
    // We group the calls together
    start_module_17(&result_object);
}
fn create_module_18() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (export \"a\" (global 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_18(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 63

#[test]
fn test_module_18() {
    let result_object = create_module_18();
    // We group the calls together
    start_module_18(&result_object);
}
fn create_module_19() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (export \"a\" (global 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_19(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 64

#[test]
fn test_module_19() {
    let result_object = create_module_19();
    // We group the calls together
    start_module_19(&result_object);
}
fn create_module_20() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (export \"a\" (global 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_20(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 65

#[test]
fn test_module_20() {
    let result_object = create_module_20();
    // We group the calls together
    start_module_20(&result_object);
}
fn create_module_21() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 0))
      (export \"a\" (global 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_21(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 67

#[test]
fn test_module_21() {
    let result_object = create_module_21();
    // We group the calls together
    start_module_21(&result_object);
}
fn create_module_22() -> ResultObject {
    let module_str = "(module
      (global (;0;) i32 (i32.const 42))
      (export \"e\" (global 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_22(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 71

// Line 72

// Line 78
#[test]
fn c32_l78_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 5, 1, 1, 97, 3, 1];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 82
#[test]
fn c33_l82_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 86
#[test]
fn c34_l86_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 65, 0, 11, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 1];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 90
#[test]
fn c35_l90_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 94
#[test]
fn c36_l94_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 1, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 98
#[test]
fn c37_l98_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 2, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 105

#[test]
fn test_module_22() {
    let result_object = create_module_22();
    // We group the calls together
    start_module_22(&result_object);
}
fn create_module_23() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 anyfunc)
      (export \"a\" (table 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_23(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 106

#[test]
fn test_module_23() {
    let result_object = create_module_23();
    // We group the calls together
    start_module_23(&result_object);
}
fn create_module_24() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 anyfunc)
      (export \"a\" (table 0))
      (export \"b\" (table 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_24(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 110

#[test]
fn test_module_24() {
    let result_object = create_module_24();
    // We group the calls together
    start_module_24(&result_object);
}
fn create_module_25() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 anyfunc)
      (export \"a\" (table 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_25(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 111

#[test]
fn test_module_25() {
    let result_object = create_module_25();
    // We group the calls together
    start_module_25(&result_object);
}
fn create_module_26() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 1 anyfunc)
      (export \"a\" (table 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_26(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 112

#[test]
fn test_module_26() {
    let result_object = create_module_26();
    // We group the calls together
    start_module_26(&result_object);
}
fn create_module_27() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 anyfunc)
      (export \"a\" (table 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_27(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 113

#[test]
fn test_module_27() {
    let result_object = create_module_27();
    // We group the calls together
    start_module_27(&result_object);
}
fn create_module_28() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 1 anyfunc)
      (export \"a\" (table 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_28(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 114

#[test]
fn test_module_28() {
    let result_object = create_module_28();
    // We group the calls together
    start_module_28(&result_object);
}
fn create_module_29() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 anyfunc)
      (export \"a\" (table 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_29(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 115

#[test]
fn test_module_29() {
    let result_object = create_module_29();
    // We group the calls together
    start_module_29(&result_object);
}
fn create_module_30() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 1 anyfunc)
      (export \"a\" (table 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_30(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 116

#[test]
fn test_module_30() {
    let result_object = create_module_30();
    // We group the calls together
    start_module_30(&result_object);
}
fn create_module_31() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 anyfunc)
      (export \"a\" (table 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_31(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 117

#[test]
fn test_module_31() {
    let result_object = create_module_31();
    // We group the calls together
    start_module_31(&result_object);
}
fn create_module_32() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 1 anyfunc)
      (export \"a\" (table 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_32(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 118

#[test]
fn test_module_32() {
    let result_object = create_module_32();
    // We group the calls together
    start_module_32(&result_object);
}
fn create_module_33() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 anyfunc)
      (export \"a\" (table 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_33(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 119

#[test]
fn test_module_33() {
    let result_object = create_module_33();
    // We group the calls together
    start_module_33(&result_object);
}
fn create_module_34() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 1 anyfunc)
      (export \"a\" (table 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_34(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 120

#[test]
fn test_module_34() {
    let result_object = create_module_34();
    // We group the calls together
    start_module_34(&result_object);
}
fn create_module_35() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 anyfunc)
      (export \"a\" (table 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_35(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 121

#[test]
fn test_module_35() {
    let result_object = create_module_35();
    // We group the calls together
    start_module_35(&result_object);
}
fn create_module_36() -> ResultObject {
    let module_str = "(module
      (table (;0;) 0 1 anyfunc)
      (export \"a\" (table 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_36(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 126
#[test]
fn c52_l126_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 5, 1, 1, 97, 1, 1];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 130
#[test]
fn c53_l130_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 1, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 139
#[test]
fn c54_l139_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 143
#[test]
fn c55_l143_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 1, 0, 1, 97, 3, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 147
#[test]
fn c56_l147_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 2, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 154

#[test]
fn test_module_36() {
    let result_object = create_module_36();
    // We group the calls together
    start_module_36(&result_object);
}
fn create_module_37() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0)
      (export \"a\" (memory 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_37(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 155

#[test]
fn test_module_37() {
    let result_object = create_module_37();
    // We group the calls together
    start_module_37(&result_object);
}
fn create_module_38() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0)
      (export \"a\" (memory 0))
      (export \"b\" (memory 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_38(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 159

#[test]
fn test_module_38() {
    let result_object = create_module_38();
    // We group the calls together
    start_module_38(&result_object);
}
fn create_module_39() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0)
      (export \"a\" (memory 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_39(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 160

#[test]
fn test_module_39() {
    let result_object = create_module_39();
    // We group the calls together
    start_module_39(&result_object);
}
fn create_module_40() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0 1)
      (export \"a\" (memory 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_40(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 161

#[test]
fn test_module_40() {
    let result_object = create_module_40();
    // We group the calls together
    start_module_40(&result_object);
}
fn create_module_41() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0)
      (export \"a\" (memory 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_41(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 162

#[test]
fn test_module_41() {
    let result_object = create_module_41();
    // We group the calls together
    start_module_41(&result_object);
}
fn create_module_42() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0 1)
      (export \"a\" (memory 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_42(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 163

#[test]
fn test_module_42() {
    let result_object = create_module_42();
    // We group the calls together
    start_module_42(&result_object);
}
fn create_module_43() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0)
      (export \"a\" (memory 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_43(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 164

#[test]
fn test_module_43() {
    let result_object = create_module_43();
    // We group the calls together
    start_module_43(&result_object);
}
fn create_module_44() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0 1)
      (export \"a\" (memory 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_44(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 165

#[test]
fn test_module_44() {
    let result_object = create_module_44();
    // We group the calls together
    start_module_44(&result_object);
}
fn create_module_45() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0)
      (export \"a\" (memory 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_45(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 166

#[test]
fn test_module_45() {
    let result_object = create_module_45();
    // We group the calls together
    start_module_45(&result_object);
}
fn create_module_46() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0 1)
      (export \"a\" (memory 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_46(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 167

#[test]
fn test_module_46() {
    let result_object = create_module_46();
    // We group the calls together
    start_module_46(&result_object);
}
fn create_module_47() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0)
      (export \"a\" (memory 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_47(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 168

#[test]
fn test_module_47() {
    let result_object = create_module_47();
    // We group the calls together
    start_module_47(&result_object);
}
fn create_module_48() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0 1)
      (export \"a\" (memory 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_48(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 169

#[test]
fn test_module_48() {
    let result_object = create_module_48();
    // We group the calls together
    start_module_48(&result_object);
}
fn create_module_49() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0)
      (export \"a\" (memory 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_49(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 170

#[test]
fn test_module_49() {
    let result_object = create_module_49();
    // We group the calls together
    start_module_49(&result_object);
}
fn create_module_50() -> ResultObject {
    let module_str = "(module
      (memory (;0;) 0 1)
      (export \"a\" (memory 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_50(result_object: &ResultObject) {
    result_object.instance.start();
}

// Line 175
#[test]
fn c71_l175_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 5, 1, 1, 97, 2, 1];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 179
#[test]
fn c72_l179_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 2, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 188
#[test]
fn c73_l188_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 192
#[test]
fn c74_l192_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 2, 0, 1, 97, 3, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

// Line 196
#[test]
fn c75_l196_assert_invalid() {
    let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 1, 0];
    let compilation = compile(wasm_binary.to_vec());
    assert!(compilation.is_err(), "WASM should not compile as is invalid");
}

#[test]
fn test_module_50() {
    let result_object = create_module_50();
    // We group the calls together
    start_module_50(&result_object);
}
