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

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

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

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


// Line 3
fn create_module_1() -> Box<Instance> {
    let module_str = "(module
      (type (;0;) (func (param i32 i32) (result i32)))
      (type (;1;) (func (param i32) (result i32)))
      (func (;0;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.add)
      (func (;1;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.sub)
      (func (;2;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.mul)
      (func (;3;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.div_s)
      (func (;4;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.div_u)
      (func (;5;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.rem_s)
      (func (;6;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.rem_u)
      (func (;7;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.and)
      (func (;8;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.or)
      (func (;9;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.xor)
      (func (;10;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.shl)
      (func (;11;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.shr_s)
      (func (;12;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.shr_u)
      (func (;13;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.rotl)
      (func (;14;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.rotr)
      (func (;15;) (type 1) (param i32) (result i32)
        get_local 0
        i32.clz)
      (func (;16;) (type 1) (param i32) (result i32)
        get_local 0
        i32.ctz)
      (func (;17;) (type 1) (param i32) (result i32)
        get_local 0
        i32.popcnt)
      (func (;18;) (type 1) (param i32) (result i32)
        get_local 0
        i32.eqz)
      (func (;19;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.eq)
      (func (;20;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.ne)
      (func (;21;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.lt_s)
      (func (;22;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.lt_u)
      (func (;23;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.le_s)
      (func (;24;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.le_u)
      (func (;25;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.gt_s)
      (func (;26;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.gt_u)
      (func (;27;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.ge_s)
      (func (;28;) (type 0) (param i32 i32) (result i32)
        get_local 0
        get_local 1
        i32.ge_u)
      (export \"add\" (func 0))
      (export \"sub\" (func 1))
      (export \"mul\" (func 2))
      (export \"div_s\" (func 3))
      (export \"div_u\" (func 4))
      (export \"rem_s\" (func 5))
      (export \"rem_u\" (func 6))
      (export \"and\" (func 7))
      (export \"or\" (func 8))
      (export \"xor\" (func 9))
      (export \"shl\" (func 10))
      (export \"shr_s\" (func 11))
      (export \"shr_u\" (func 12))
      (export \"rotl\" (func 13))
      (export \"rotr\" (func 14))
      (export \"clz\" (func 15))
      (export \"ctz\" (func 16))
      (export \"popcnt\" (func 17))
      (export \"eqz\" (func 18))
      (export \"eq\" (func 19))
      (export \"ne\" (func 20))
      (export \"lt_s\" (func 21))
      (export \"lt_u\" (func 22))
      (export \"le_s\" (func 23))
      (export \"le_u\" (func 24))
      (export \"gt_s\" (func 25))
      (export \"gt_u\" (func 26))
      (export \"ge_s\" (func 27))
      (export \"ge_u\" (func 28)))
    ";
    let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
    let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
    module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Line 59
fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c23_l59_action_invoke");
    let result = instance.call("mul", &[Value::I32(19088743 as i32), Value::I32(1985229328 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(898528368 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Line 75
fn c38_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c38_l75_action_invoke");
    let result = instance.call("div_s", &[Value::I32(7 as i32), Value::I32(3 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

// Line 76
fn c39_l76_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c39_l76_action_invoke");
    let result = instance.call("div_s", &[Value::I32(-7 as i32), Value::I32(3 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(-2 as i32))));
    result.map(|_| ())
}

// Line 77
fn c40_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c40_l77_action_invoke");
    let result = instance.call("div_s", &[Value::I32(7 as i32), Value::I32(-3 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(-2 as i32))));
    result.map(|_| ())
}

// Line 78
fn c41_l78_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c41_l78_action_invoke");
    let result = instance.call("div_s", &[Value::I32(-7 as i32), Value::I32(-3 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

// Line 79
fn c42_l79_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c42_l79_action_invoke");
    let result = instance.call("div_s", &[Value::I32(11 as i32), Value::I32(5 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

// Line 80
fn c43_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c43_l80_action_invoke");
    let result = instance.call("div_s", &[Value::I32(17 as i32), Value::I32(7 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

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

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

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

// Line 92
fn c54_l92_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c54_l92_action_invoke");
    let result = instance.call("div_u", &[Value::I32(-5 as i32), Value::I32(2 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(2147483645 as i32))));
    result.map(|_| ())
}

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

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

// Line 95
fn c57_l95_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c57_l95_action_invoke");
    let result = instance.call("div_u", &[Value::I32(7 as i32), Value::I32(3 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

// Line 96
fn c58_l96_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c58_l96_action_invoke");
    let result = instance.call("div_u", &[Value::I32(11 as i32), Value::I32(5 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

// Line 97
fn c59_l97_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c59_l97_action_invoke");
    let result = instance.call("div_u", &[Value::I32(17 as i32), Value::I32(7 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(2 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Line 118
fn c79_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c79_l118_action_invoke");
    let result = instance.call("rem_s", &[Value::I32(17 as i32), Value::I32(7 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(3 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Line 135
fn c95_l135_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c95_l135_action_invoke");
    let result = instance.call("rem_u", &[Value::I32(17 as i32), Value::I32(7 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(3 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

// Line 143
fn c102_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c102_l143_action_invoke");
    let result = instance.call("and", &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(-252645136 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Line 163
fn c120_l163_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c120_l163_action_invoke");
    let result = instance.call("xor", &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(252645135 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Line 220
fn c173_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c173_l220_action_invoke");
    let result = instance.call("rotl", &[Value::I32(-1329474845 as i32), Value::I32(5 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(406477942 as i32))));
    result.map(|_| ())
}

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

// Line 222
fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c175_l222_action_invoke");
    let result = instance.call("rotl", &[Value::I32(-1329474845 as i32), Value::I32(65285 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(406477942 as i32))));
    result.map(|_| ())
}

// Line 223
fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c176_l223_action_invoke");
    let result = instance.call("rotl", &[Value::I32(1989852383 as i32), Value::I32(-19 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(1469837011 as i32))));
    result.map(|_| ())
}

// Line 224
fn c177_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c177_l224_action_invoke");
    let result = instance.call("rotl", &[Value::I32(1989852383 as i32), Value::I32(-2147483635 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(1469837011 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

// Line 234
fn c186_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c186_l234_action_invoke");
    let result = instance.call("rotr", &[Value::I32(-1329474845 as i32), Value::I32(5 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(495324823 as i32))));
    result.map(|_| ())
}

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

// Line 236
fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c188_l236_action_invoke");
    let result = instance.call("rotr", &[Value::I32(-1329474845 as i32), Value::I32(65285 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(495324823 as i32))));
    result.map(|_| ())
}

// Line 237
fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c189_l237_action_invoke");
    let result = instance.call("rotr", &[Value::I32(1989852383 as i32), Value::I32(-19 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(-419711787 as i32))));
    result.map(|_| ())
}

// Line 238
fn c190_l238_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c190_l238_action_invoke");
    let result = instance.call("rotr", &[Value::I32(1989852383 as i32), Value::I32(-2147483635 as i32)]);
    assert_eq!(result, Ok(Some(Value::I32(-419711787 as i32))));
    result.map(|_| ())
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[test]
fn test_module_1() {
    let mut instance = create_module_1();
    // We group the calls together
    start_module_1(&mut instance);
    c1_l35_action_invoke(&mut instance);
    c2_l36_action_invoke(&mut instance);
    c3_l37_action_invoke(&mut instance);
    c4_l38_action_invoke(&mut instance);
    c5_l39_action_invoke(&mut instance);
    c6_l40_action_invoke(&mut instance);
    c7_l41_action_invoke(&mut instance);
    c8_l42_action_invoke(&mut instance);
    c9_l44_action_invoke(&mut instance);
    c10_l45_action_invoke(&mut instance);
    c11_l46_action_invoke(&mut instance);
    c12_l47_action_invoke(&mut instance);
    c13_l48_action_invoke(&mut instance);
    c14_l49_action_invoke(&mut instance);
    c15_l50_action_invoke(&mut instance);
    c16_l52_action_invoke(&mut instance);
    c17_l53_action_invoke(&mut instance);
    c18_l54_action_invoke(&mut instance);
    c19_l55_action_invoke(&mut instance);
    c20_l56_action_invoke(&mut instance);
    c21_l57_action_invoke(&mut instance);
    c22_l58_action_invoke(&mut instance);
    c23_l59_action_invoke(&mut instance);
    c24_l60_action_invoke(&mut instance);
    c28_l65_action_invoke(&mut instance);
    c29_l66_action_invoke(&mut instance);
    c30_l67_action_invoke(&mut instance);
    c31_l68_action_invoke(&mut instance);
    c32_l69_action_invoke(&mut instance);
    c33_l70_action_invoke(&mut instance);
    c34_l71_action_invoke(&mut instance);
    c35_l72_action_invoke(&mut instance);
    c36_l73_action_invoke(&mut instance);
    c37_l74_action_invoke(&mut instance);
    c38_l75_action_invoke(&mut instance);
    c39_l76_action_invoke(&mut instance);
    c40_l77_action_invoke(&mut instance);
    c41_l78_action_invoke(&mut instance);
    c42_l79_action_invoke(&mut instance);
    c43_l80_action_invoke(&mut instance);
    c46_l84_action_invoke(&mut instance);
    c47_l85_action_invoke(&mut instance);
    c48_l86_action_invoke(&mut instance);
    c49_l87_action_invoke(&mut instance);
    c50_l88_action_invoke(&mut instance);
    c51_l89_action_invoke(&mut instance);
    c52_l90_action_invoke(&mut instance);
    c53_l91_action_invoke(&mut instance);
    c54_l92_action_invoke(&mut instance);
    c55_l93_action_invoke(&mut instance);
    c56_l94_action_invoke(&mut instance);
    c57_l95_action_invoke(&mut instance);
    c58_l96_action_invoke(&mut instance);
    c59_l97_action_invoke(&mut instance);
    c62_l101_action_invoke(&mut instance);
    c63_l102_action_invoke(&mut instance);
    c64_l103_action_invoke(&mut instance);
    c65_l104_action_invoke(&mut instance);
    c66_l105_action_invoke(&mut instance);
    c67_l106_action_invoke(&mut instance);
    c68_l107_action_invoke(&mut instance);
    c69_l108_action_invoke(&mut instance);
    c70_l109_action_invoke(&mut instance);
    c71_l110_action_invoke(&mut instance);
    c72_l111_action_invoke(&mut instance);
    c73_l112_action_invoke(&mut instance);
    c74_l113_action_invoke(&mut instance);
    c75_l114_action_invoke(&mut instance);
    c76_l115_action_invoke(&mut instance);
    c77_l116_action_invoke(&mut instance);
    c78_l117_action_invoke(&mut instance);
    c79_l118_action_invoke(&mut instance);
    c82_l122_action_invoke(&mut instance);
    c83_l123_action_invoke(&mut instance);
    c84_l124_action_invoke(&mut instance);
    c85_l125_action_invoke(&mut instance);
    c86_l126_action_invoke(&mut instance);
    c87_l127_action_invoke(&mut instance);
    c88_l128_action_invoke(&mut instance);
    c89_l129_action_invoke(&mut instance);
    c90_l130_action_invoke(&mut instance);
    c91_l131_action_invoke(&mut instance);
    c92_l132_action_invoke(&mut instance);
    c93_l133_action_invoke(&mut instance);
    c94_l134_action_invoke(&mut instance);
    c95_l135_action_invoke(&mut instance);
    c96_l137_action_invoke(&mut instance);
    c97_l138_action_invoke(&mut instance);
    c98_l139_action_invoke(&mut instance);
    c99_l140_action_invoke(&mut instance);
    c100_l141_action_invoke(&mut instance);
    c101_l142_action_invoke(&mut instance);
    c102_l143_action_invoke(&mut instance);
    c103_l144_action_invoke(&mut instance);
    c104_l146_action_invoke(&mut instance);
    c105_l147_action_invoke(&mut instance);
    c106_l148_action_invoke(&mut instance);
    c107_l149_action_invoke(&mut instance);
    c108_l150_action_invoke(&mut instance);
    c109_l151_action_invoke(&mut instance);
    c110_l152_action_invoke(&mut instance);
    c111_l153_action_invoke(&mut instance);
    c112_l155_action_invoke(&mut instance);
    c113_l156_action_invoke(&mut instance);
    c114_l157_action_invoke(&mut instance);
    c115_l158_action_invoke(&mut instance);
    c116_l159_action_invoke(&mut instance);
    c117_l160_action_invoke(&mut instance);
    c118_l161_action_invoke(&mut instance);
    c119_l162_action_invoke(&mut instance);
    c120_l163_action_invoke(&mut instance);
    c121_l164_action_invoke(&mut instance);
    c122_l166_action_invoke(&mut instance);
    c123_l167_action_invoke(&mut instance);
    c124_l168_action_invoke(&mut instance);
    c125_l169_action_invoke(&mut instance);
    c126_l170_action_invoke(&mut instance);
    c127_l171_action_invoke(&mut instance);
    c128_l172_action_invoke(&mut instance);
    c129_l173_action_invoke(&mut instance);
    c130_l174_action_invoke(&mut instance);
    c131_l175_action_invoke(&mut instance);
    c132_l176_action_invoke(&mut instance);
    c133_l178_action_invoke(&mut instance);
    c134_l179_action_invoke(&mut instance);
    c135_l180_action_invoke(&mut instance);
    c136_l181_action_invoke(&mut instance);
    c137_l182_action_invoke(&mut instance);
    c138_l183_action_invoke(&mut instance);
    c139_l184_action_invoke(&mut instance);
    c140_l185_action_invoke(&mut instance);
    c141_l186_action_invoke(&mut instance);
    c142_l187_action_invoke(&mut instance);
    c143_l188_action_invoke(&mut instance);
    c144_l189_action_invoke(&mut instance);
    c145_l190_action_invoke(&mut instance);
    c146_l191_action_invoke(&mut instance);
    c147_l192_action_invoke(&mut instance);
    c148_l193_action_invoke(&mut instance);
    c149_l194_action_invoke(&mut instance);
    c150_l196_action_invoke(&mut instance);
    c151_l197_action_invoke(&mut instance);
    c152_l198_action_invoke(&mut instance);
    c153_l199_action_invoke(&mut instance);
    c154_l200_action_invoke(&mut instance);
    c155_l201_action_invoke(&mut instance);
    c156_l202_action_invoke(&mut instance);
    c157_l203_action_invoke(&mut instance);
    c158_l204_action_invoke(&mut instance);
    c159_l205_action_invoke(&mut instance);
    c160_l206_action_invoke(&mut instance);
    c161_l207_action_invoke(&mut instance);
    c162_l208_action_invoke(&mut instance);
    c163_l209_action_invoke(&mut instance);
    c164_l210_action_invoke(&mut instance);
    c165_l211_action_invoke(&mut instance);
    c166_l212_action_invoke(&mut instance);
    c167_l214_action_invoke(&mut instance);
    c168_l215_action_invoke(&mut instance);
    c169_l216_action_invoke(&mut instance);
    c170_l217_action_invoke(&mut instance);
    c171_l218_action_invoke(&mut instance);
    c172_l219_action_invoke(&mut instance);
    c173_l220_action_invoke(&mut instance);
    c174_l221_action_invoke(&mut instance);
    c175_l222_action_invoke(&mut instance);
    c176_l223_action_invoke(&mut instance);
    c177_l224_action_invoke(&mut instance);
    c178_l225_action_invoke(&mut instance);
    c179_l226_action_invoke(&mut instance);
    c180_l228_action_invoke(&mut instance);
    c181_l229_action_invoke(&mut instance);
    c182_l230_action_invoke(&mut instance);
    c183_l231_action_invoke(&mut instance);
    c184_l232_action_invoke(&mut instance);
    c185_l233_action_invoke(&mut instance);
    c186_l234_action_invoke(&mut instance);
    c187_l235_action_invoke(&mut instance);
    c188_l236_action_invoke(&mut instance);
    c189_l237_action_invoke(&mut instance);
    c190_l238_action_invoke(&mut instance);
    c191_l239_action_invoke(&mut instance);
    c192_l240_action_invoke(&mut instance);
    c193_l242_action_invoke(&mut instance);
    c194_l243_action_invoke(&mut instance);
    c195_l244_action_invoke(&mut instance);
    c196_l245_action_invoke(&mut instance);
    c197_l246_action_invoke(&mut instance);
    c198_l247_action_invoke(&mut instance);
    c199_l248_action_invoke(&mut instance);
    c200_l249_action_invoke(&mut instance);
    c201_l251_action_invoke(&mut instance);
    c202_l252_action_invoke(&mut instance);
    c203_l253_action_invoke(&mut instance);
    c204_l254_action_invoke(&mut instance);
    c205_l255_action_invoke(&mut instance);
    c206_l256_action_invoke(&mut instance);
    c207_l258_action_invoke(&mut instance);
    c208_l259_action_invoke(&mut instance);
    c209_l260_action_invoke(&mut instance);
    c210_l261_action_invoke(&mut instance);
    c211_l262_action_invoke(&mut instance);
    c212_l263_action_invoke(&mut instance);
    c213_l264_action_invoke(&mut instance);
    c214_l265_action_invoke(&mut instance);
    c215_l267_action_invoke(&mut instance);
    c216_l268_action_invoke(&mut instance);
    c217_l269_action_invoke(&mut instance);
    c218_l270_action_invoke(&mut instance);
    c219_l271_action_invoke(&mut instance);
    c220_l273_action_invoke(&mut instance);
    c221_l274_action_invoke(&mut instance);
    c222_l275_action_invoke(&mut instance);
    c223_l276_action_invoke(&mut instance);
    c224_l277_action_invoke(&mut instance);
    c225_l278_action_invoke(&mut instance);
    c226_l279_action_invoke(&mut instance);
    c227_l280_action_invoke(&mut instance);
    c228_l281_action_invoke(&mut instance);
    c229_l282_action_invoke(&mut instance);
    c230_l283_action_invoke(&mut instance);
    c231_l284_action_invoke(&mut instance);
    c232_l285_action_invoke(&mut instance);
    c233_l286_action_invoke(&mut instance);
    c234_l288_action_invoke(&mut instance);
    c235_l289_action_invoke(&mut instance);
    c236_l290_action_invoke(&mut instance);
    c237_l291_action_invoke(&mut instance);
    c238_l292_action_invoke(&mut instance);
    c239_l293_action_invoke(&mut instance);
    c240_l294_action_invoke(&mut instance);
    c241_l295_action_invoke(&mut instance);
    c242_l296_action_invoke(&mut instance);
    c243_l297_action_invoke(&mut instance);
    c244_l298_action_invoke(&mut instance);
    c245_l299_action_invoke(&mut instance);
    c246_l300_action_invoke(&mut instance);
    c247_l301_action_invoke(&mut instance);
    c248_l303_action_invoke(&mut instance);
    c249_l304_action_invoke(&mut instance);
    c250_l305_action_invoke(&mut instance);
    c251_l306_action_invoke(&mut instance);
    c252_l307_action_invoke(&mut instance);
    c253_l308_action_invoke(&mut instance);
    c254_l309_action_invoke(&mut instance);
    c255_l310_action_invoke(&mut instance);
    c256_l311_action_invoke(&mut instance);
    c257_l312_action_invoke(&mut instance);
    c258_l313_action_invoke(&mut instance);
    c259_l314_action_invoke(&mut instance);
    c260_l315_action_invoke(&mut instance);
    c261_l316_action_invoke(&mut instance);
    c262_l318_action_invoke(&mut instance);
    c263_l319_action_invoke(&mut instance);
    c264_l320_action_invoke(&mut instance);
    c265_l321_action_invoke(&mut instance);
    c266_l322_action_invoke(&mut instance);
    c267_l323_action_invoke(&mut instance);
    c268_l324_action_invoke(&mut instance);
    c269_l325_action_invoke(&mut instance);
    c270_l326_action_invoke(&mut instance);
    c271_l327_action_invoke(&mut instance);
    c272_l328_action_invoke(&mut instance);
    c273_l329_action_invoke(&mut instance);
    c274_l330_action_invoke(&mut instance);
    c275_l331_action_invoke(&mut instance);
    c276_l333_action_invoke(&mut instance);
    c277_l334_action_invoke(&mut instance);
    c278_l335_action_invoke(&mut instance);
    c279_l336_action_invoke(&mut instance);
    c280_l337_action_invoke(&mut instance);
    c281_l338_action_invoke(&mut instance);
    c282_l339_action_invoke(&mut instance);
    c283_l340_action_invoke(&mut instance);
    c284_l341_action_invoke(&mut instance);
    c285_l342_action_invoke(&mut instance);
    c286_l343_action_invoke(&mut instance);
    c287_l344_action_invoke(&mut instance);
    c288_l345_action_invoke(&mut instance);
    c289_l346_action_invoke(&mut instance);
    c290_l348_action_invoke(&mut instance);
    c291_l349_action_invoke(&mut instance);
    c292_l350_action_invoke(&mut instance);
    c293_l351_action_invoke(&mut instance);
    c294_l352_action_invoke(&mut instance);
    c295_l353_action_invoke(&mut instance);
    c296_l354_action_invoke(&mut instance);
    c297_l355_action_invoke(&mut instance);
    c298_l356_action_invoke(&mut instance);
    c299_l357_action_invoke(&mut instance);
    c300_l358_action_invoke(&mut instance);
    c301_l359_action_invoke(&mut instance);
    c302_l360_action_invoke(&mut instance);
    c303_l361_action_invoke(&mut instance);
    c304_l363_action_invoke(&mut instance);
    c305_l364_action_invoke(&mut instance);
    c306_l365_action_invoke(&mut instance);
    c307_l366_action_invoke(&mut instance);
    c308_l367_action_invoke(&mut instance);
    c309_l368_action_invoke(&mut instance);
    c310_l369_action_invoke(&mut instance);
    c311_l370_action_invoke(&mut instance);
    c312_l371_action_invoke(&mut instance);
    c313_l372_action_invoke(&mut instance);
    c314_l373_action_invoke(&mut instance);
    c315_l374_action_invoke(&mut instance);
    c316_l375_action_invoke(&mut instance);
    c317_l376_action_invoke(&mut instance);
    c318_l378_action_invoke(&mut instance);
    c319_l379_action_invoke(&mut instance);
    c320_l380_action_invoke(&mut instance);
    c321_l381_action_invoke(&mut instance);
    c322_l382_action_invoke(&mut instance);
    c323_l383_action_invoke(&mut instance);
    c324_l384_action_invoke(&mut instance);
    c325_l385_action_invoke(&mut instance);
    c326_l386_action_invoke(&mut instance);
    c327_l387_action_invoke(&mut instance);
    c328_l388_action_invoke(&mut instance);
    c329_l389_action_invoke(&mut instance);
    c330_l390_action_invoke(&mut instance);
    c331_l391_action_invoke(&mut instance);
    c332_l393_action_invoke(&mut instance);
    c333_l394_action_invoke(&mut instance);
    c334_l395_action_invoke(&mut instance);
    c335_l396_action_invoke(&mut instance);
    c336_l397_action_invoke(&mut instance);
    c337_l398_action_invoke(&mut instance);
    c338_l399_action_invoke(&mut instance);
    c339_l400_action_invoke(&mut instance);
    c340_l401_action_invoke(&mut instance);
    c341_l402_action_invoke(&mut instance);
    c342_l403_action_invoke(&mut instance);
    c343_l404_action_invoke(&mut instance);
    c344_l405_action_invoke(&mut instance);
    c345_l406_action_invoke(&mut instance);
    c346_l408_action_invoke(&mut instance);
    c347_l409_action_invoke(&mut instance);
    c348_l410_action_invoke(&mut instance);
    c349_l411_action_invoke(&mut instance);
    c350_l412_action_invoke(&mut instance);
    c351_l413_action_invoke(&mut instance);
    c352_l414_action_invoke(&mut instance);
    c353_l415_action_invoke(&mut instance);
    c354_l416_action_invoke(&mut instance);
    c355_l417_action_invoke(&mut instance);
    c356_l418_action_invoke(&mut instance);
    c357_l419_action_invoke(&mut instance);
    c358_l420_action_invoke(&mut instance);
    c359_l421_action_invoke(&mut instance);
}