// 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/f32_.wast
#![allow(
    warnings,
    dead_code
)]
use wabt::wat2wasm;
use std::{f32, f64};

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

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


// Line 5
fn create_module_1() -> Box<Instance> {
    let module_str = "(module
      (type (;0;) (func (param f32 f32) (result f32)))
      (type (;1;) (func (param f32) (result f32)))
      (func (;0;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.add)
      (func (;1;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.sub)
      (func (;2;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.mul)
      (func (;3;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.div)
      (func (;4;) (type 1) (param f32) (result f32)
        get_local 0
        f32.sqrt)
      (func (;5;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.min)
      (func (;6;) (type 0) (param f32 f32) (result f32)
        get_local 0
        get_local 1
        f32.max)
      (func (;7;) (type 1) (param f32) (result f32)
        get_local 0
        f32.ceil)
      (func (;8;) (type 1) (param f32) (result f32)
        get_local 0
        f32.floor)
      (func (;9;) (type 1) (param f32) (result f32)
        get_local 0
        f32.trunc)
      (func (;10;) (type 1) (param f32) (result f32)
        get_local 0
        f32.nearest)
      (export \"add\" (func 0))
      (export \"sub\" (func 1))
      (export \"mul\" (func 2))
      (export \"div\" (func 3))
      (export \"sqrt\" (func 4))
      (export \"min\" (func 5))
      (export \"max\" (func 6))
      (export \"ceil\" (func 7))
      (export \"floor\" (func 8))
      (export \"trunc\" (func 9))
      (export \"nearest\" (func 10)))
    ";
    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 19
fn c1_l19_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1_l19_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 20
fn c2_l20_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2_l20_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 21
fn c3_l21_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c3_l21_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 22
fn c4_l22_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c4_l22_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 23
fn c5_l23_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c5_l23_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 24
fn c6_l24_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c6_l24_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 25
fn c7_l25_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c7_l25_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 26
fn c8_l26_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c8_l26_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 27
fn c9_l27_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c9_l27_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 28
fn c10_l28_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c10_l28_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 29
fn c11_l29_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c11_l29_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 30
fn c12_l30_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c12_l30_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 31
fn c13_l31_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c13_l31_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 32
fn c14_l32_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c14_l32_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 33
fn c15_l33_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c15_l33_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 34
fn c16_l34_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c16_l34_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 35
fn c17_l35_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c17_l35_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 36
fn c18_l36_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c18_l36_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 37
fn c19_l37_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c19_l37_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 38
fn c20_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c20_l38_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 39
fn c21_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c21_l39_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 40
fn c22_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c22_l40_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 41
fn c23_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c23_l41_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 42
fn c24_l42_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c24_l42_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 43
fn c25_l43_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c25_l43_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 44
fn c26_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c26_l44_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 45
fn c27_l45_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c27_l45_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 46
fn c28_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c28_l46_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 47
fn c29_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c29_l47_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 48
fn c30_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c30_l48_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 49
fn c31_l49_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c31_l49_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 50
fn c32_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c32_l50_action_invoke");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 51
fn c33_l51_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c33_l51_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c33_l51_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 52
fn c34_l52_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c34_l52_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c34_l52_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 53
fn c35_l53_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c35_l53_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c35_l53_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 54
fn c36_l54_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c36_l54_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c36_l54_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 55
fn c37_l55_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c37_l55_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c37_l55_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 56
fn c38_l56_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c38_l56_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c38_l56_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 57
fn c39_l57_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c39_l57_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c39_l57_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 58
fn c40_l58_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c40_l58_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c40_l58_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 59
fn c41_l59_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c41_l59_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 60
fn c42_l60_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c42_l60_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 61
fn c43_l61_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c43_l61_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 62
fn c44_l62_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c44_l62_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 63
fn c45_l63_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c45_l63_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits()))));
    result.map(|_| ())
}

// Line 64
fn c46_l64_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c46_l64_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 65
fn c47_l65_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c47_l65_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 66
fn c48_l66_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c48_l66_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits()))));
    result.map(|_| ())
}

// Line 67
fn c49_l67_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c49_l67_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32).to_bits()))));
    result.map(|_| ())
}

// Line 68
fn c50_l68_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c50_l68_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 69
fn c51_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c51_l69_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 70
fn c52_l70_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c52_l70_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32).to_bits()))));
    result.map(|_| ())
}

// Line 71
fn c53_l71_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c53_l71_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 72
fn c54_l72_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c54_l72_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 73
fn c55_l73_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c55_l73_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 74
fn c56_l74_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c56_l74_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 75
fn c57_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c57_l75_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 76
fn c58_l76_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c58_l76_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 77
fn c59_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c59_l77_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 78
fn c60_l78_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c60_l78_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 79
fn c61_l79_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c61_l79_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 80
fn c62_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c62_l80_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 81
fn c63_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c63_l81_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 82
fn c64_l82_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c64_l82_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 83
fn c65_l83_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c65_l83_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 84
fn c66_l84_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c66_l84_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 85
fn c67_l85_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c67_l85_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 86
fn c68_l86_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c68_l86_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 87
fn c69_l87_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c69_l87_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 88
fn c70_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c70_l88_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 89
fn c71_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c71_l89_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 90
fn c72_l90_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c72_l90_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 91
fn c73_l91_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c73_l91_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c73_l91_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 92
fn c74_l92_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c74_l92_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c74_l92_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 93
fn c75_l93_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c75_l93_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c75_l93_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 94
fn c76_l94_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c76_l94_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c76_l94_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 95
fn c77_l95_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c77_l95_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c77_l95_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 96
fn c78_l96_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c78_l96_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c78_l96_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 97
fn c79_l97_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c79_l97_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c79_l97_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 98
fn c80_l98_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c80_l98_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c80_l98_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 99
fn c81_l99_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c81_l99_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 100
fn c82_l100_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c82_l100_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 101
fn c83_l101_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c83_l101_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 102
fn c84_l102_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c84_l102_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 103
fn c85_l103_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c85_l103_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32).to_bits()))));
    result.map(|_| ())
}

// Line 104
fn c86_l104_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c86_l104_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 105
fn c87_l105_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c87_l105_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 106
fn c88_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c88_l106_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32).to_bits()))));
    result.map(|_| ())
}

// Line 107
fn c89_l107_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c89_l107_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32).to_bits()))));
    result.map(|_| ())
}

// Line 108
fn c90_l108_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c90_l108_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 109
fn c91_l109_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c91_l109_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 110
fn c92_l110_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c92_l110_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits()))));
    result.map(|_| ())
}

// Line 111
fn c93_l111_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c93_l111_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 112
fn c94_l112_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c94_l112_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 113
fn c95_l113_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c95_l113_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 114
fn c96_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c96_l114_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 115
fn c97_l115_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c97_l115_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 116
fn c98_l116_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c98_l116_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 117
fn c99_l117_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c99_l117_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 118
fn c100_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c100_l118_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 119
fn c101_l119_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c101_l119_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 120
fn c102_l120_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c102_l120_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 121
fn c103_l121_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c103_l121_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 122
fn c104_l122_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c104_l122_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 123
fn c105_l123_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c105_l123_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 124
fn c106_l124_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c106_l124_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 125
fn c107_l125_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c107_l125_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 126
fn c108_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c108_l126_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 127
fn c109_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c109_l127_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 128
fn c110_l128_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c110_l128_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 129
fn c111_l129_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c111_l129_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 130
fn c112_l130_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c112_l130_action_invoke");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 131
fn c113_l131_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c113_l131_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c113_l131_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 132
fn c114_l132_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c114_l132_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c114_l132_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 133
fn c115_l133_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c115_l133_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c115_l133_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 134
fn c116_l134_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c116_l134_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c116_l134_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 135
fn c117_l135_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c117_l135_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c117_l135_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 136
fn c118_l136_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c118_l136_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c118_l136_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 137
fn c119_l137_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c119_l137_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c119_l137_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 138
fn c120_l138_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c120_l138_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c120_l138_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 139
fn c121_l139_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c121_l139_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 140
fn c122_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c122_l140_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 141
fn c123_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c123_l141_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 142
fn c124_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c124_l142_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 143
fn c125_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c125_l143_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 144
fn c126_l144_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c126_l144_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 145
fn c127_l145_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c127_l145_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 146
fn c128_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c128_l146_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 147
fn c129_l147_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c129_l147_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 148
fn c130_l148_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c130_l148_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 149
fn c131_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c131_l149_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 150
fn c132_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c132_l150_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 151
fn c133_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c133_l151_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 152
fn c134_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c134_l152_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 153
fn c135_l153_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c135_l153_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 154
fn c136_l154_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c136_l154_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 155
fn c137_l155_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c137_l155_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 156
fn c138_l156_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c138_l156_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 157
fn c139_l157_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c139_l157_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 158
fn c140_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c140_l158_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 159
fn c141_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c141_l159_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 160
fn c142_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c142_l160_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 161
fn c143_l161_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c143_l161_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-5.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 162
fn c144_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c144_l162_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 163
fn c145_l163_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c145_l163_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 164
fn c146_l164_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c146_l164_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 165
fn c147_l165_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c147_l165_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 166
fn c148_l166_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c148_l166_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 167
fn c149_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c149_l167_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 168
fn c150_l168_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c150_l168_action_invoke");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 169
fn c151_l169_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c151_l169_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 170
fn c152_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c152_l170_action_invoke");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 171
fn c153_l171_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c153_l171_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c153_l171_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 172
fn c154_l172_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c154_l172_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c154_l172_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 173
fn c155_l173_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c155_l173_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c155_l173_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 174
fn c156_l174_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c156_l174_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c156_l174_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 175
fn c157_l175_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c157_l175_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c157_l175_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 176
fn c158_l176_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c158_l176_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c158_l176_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 177
fn c159_l177_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c159_l177_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c159_l177_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 178
fn c160_l178_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c160_l178_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c160_l178_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 179
fn c161_l179_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c161_l179_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 180
fn c162_l180_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c162_l180_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 181
fn c163_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c163_l181_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 182
fn c164_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c164_l182_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 183
fn c165_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c165_l183_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 184
fn c166_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c166_l184_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 185
fn c167_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c167_l185_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 186
fn c168_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c168_l186_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 187
fn c169_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c169_l187_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 188
fn c170_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c170_l188_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 189
fn c171_l189_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c171_l189_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 190
fn c172_l190_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c172_l190_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 191
fn c173_l191_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c173_l191_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 192
fn c174_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c174_l192_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 193
fn c175_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c175_l193_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 194
fn c176_l194_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c176_l194_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 195
fn c177_l195_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c177_l195_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 196
fn c178_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c178_l196_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 197
fn c179_l197_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c179_l197_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 198
fn c180_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c180_l198_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 199
fn c181_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c181_l199_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-7.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 200
fn c182_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c182_l200_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 201
fn c183_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c183_l201_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-5.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 202
fn c184_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c184_l202_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((7.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 203
fn c185_l203_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c185_l203_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 204
fn c186_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c186_l204_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 205
fn c187_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c187_l205_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 206
fn c188_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c188_l206_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 207
fn c189_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c189_l207_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 208
fn c190_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c190_l208_action_invoke");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 209
fn c191_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c191_l209_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 210
fn c192_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c192_l210_action_invoke");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 211
fn c193_l211_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c193_l211_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c193_l211_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 212
fn c194_l212_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c194_l212_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c194_l212_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 213
fn c195_l213_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c195_l213_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c195_l213_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 214
fn c196_l214_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c196_l214_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c196_l214_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 215
fn c197_l215_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c197_l215_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c197_l215_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 216
fn c198_l216_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c198_l216_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c198_l216_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 217
fn c199_l217_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c199_l217_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c199_l217_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 218
fn c200_l218_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c200_l218_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c200_l218_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 219
fn c201_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c201_l219_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 220
fn c202_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c202_l220_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 221
fn c203_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c203_l221_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 222
fn c204_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c204_l222_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 223
fn c205_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c205_l223_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 224
fn c206_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c206_l224_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 225
fn c207_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c207_l225_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 226
fn c208_l226_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c208_l226_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 227
fn c209_l227_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c209_l227_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 228
fn c210_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c210_l228_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 229
fn c211_l229_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c211_l229_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 230
fn c212_l230_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c212_l230_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 231
fn c213_l231_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c213_l231_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 232
fn c214_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c214_l232_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-5.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 233
fn c215_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c215_l233_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 234
fn c216_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c216_l234_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 235
fn c217_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c217_l235_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-7.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 236
fn c218_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c218_l236_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-5.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 237
fn c219_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c219_l237_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 238
fn c220_l238_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c220_l238_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((7.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 239
fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c221_l239_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-12.566371f32).to_bits()))));
    result.map(|_| ())
}

// Line 240
fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c222_l240_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 241
fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c223_l241_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 242
fn c224_l242_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c224_l242_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((12.566371f32).to_bits()))));
    result.map(|_| ())
}

// Line 243
fn c225_l243_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c225_l243_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 244
fn c226_l244_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c226_l244_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 245
fn c227_l245_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c227_l245_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 246
fn c228_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c228_l246_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 247
fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c229_l247_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 248
fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c230_l248_action_invoke");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 249
fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c231_l249_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 250
fn c232_l250_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c232_l250_action_invoke");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 251
fn c233_l251_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c233_l251_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c233_l251_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 252
fn c234_l252_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c234_l252_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c234_l252_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 253
fn c235_l253_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c235_l253_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c235_l253_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 254
fn c236_l254_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c236_l254_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c236_l254_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 255
fn c237_l255_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c237_l255_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c237_l255_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 256
fn c238_l256_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c238_l256_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c238_l256_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 257
fn c239_l257_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c239_l257_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c239_l257_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 258
fn c240_l258_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c240_l258_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c240_l258_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 259
fn c241_l259_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c241_l259_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 260
fn c242_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c242_l260_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 261
fn c243_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c243_l261_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 262
fn c244_l262_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c244_l262_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 263
fn c245_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c245_l263_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 264
fn c246_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c246_l264_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 265
fn c247_l265_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c247_l265_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 266
fn c248_l266_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c248_l266_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 267
fn c249_l267_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c249_l267_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 268
fn c250_l268_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c250_l268_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 269
fn c251_l269_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c251_l269_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 270
fn c252_l270_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c252_l270_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 271
fn c253_l271_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c253_l271_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 272
fn c254_l272_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c254_l272_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 273
fn c255_l273_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c255_l273_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 274
fn c256_l274_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c256_l274_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 275
fn c257_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c257_l275_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 276
fn c258_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c258_l276_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 277
fn c259_l277_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c259_l277_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 278
fn c260_l278_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c260_l278_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 279
fn c261_l279_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c261_l279_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 280
fn c262_l280_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c262_l280_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 281
fn c263_l281_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c263_l281_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 282
fn c264_l282_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c264_l282_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 283
fn c265_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c265_l283_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 284
fn c266_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c266_l284_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 285
fn c267_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c267_l285_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 286
fn c268_l286_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c268_l286_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 287
fn c269_l287_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c269_l287_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 288
fn c270_l288_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c270_l288_action_invoke");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 289
fn c271_l289_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c271_l289_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 290
fn c272_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c272_l290_action_invoke");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 291
fn c273_l291_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c273_l291_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c273_l291_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 292
fn c274_l292_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c274_l292_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c274_l292_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 293
fn c275_l293_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c275_l293_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c275_l293_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 294
fn c276_l294_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c276_l294_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c276_l294_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 295
fn c277_l295_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c277_l295_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c277_l295_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 296
fn c278_l296_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c278_l296_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c278_l296_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 297
fn c279_l297_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c279_l297_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c279_l297_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 298
fn c280_l298_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c280_l298_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c280_l298_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 299
fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c281_l299_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 300
fn c282_l300_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c282_l300_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 301
fn c283_l301_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c283_l301_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 302
fn c284_l302_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c284_l302_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 303
fn c285_l303_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c285_l303_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 304
fn c286_l304_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c286_l304_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 305
fn c287_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c287_l305_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 306
fn c288_l306_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c288_l306_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 307
fn c289_l307_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c289_l307_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 308
fn c290_l308_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c290_l308_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 309
fn c291_l309_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c291_l309_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 310
fn c292_l310_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c292_l310_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 311
fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c293_l311_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 312
fn c294_l312_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c294_l312_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 313
fn c295_l313_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c295_l313_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 314
fn c296_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c296_l314_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 315
fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c297_l315_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 316
fn c298_l316_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c298_l316_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 317
fn c299_l317_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c299_l317_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 318
fn c300_l318_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c300_l318_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 319
fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c301_l319_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 320
fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c302_l320_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 321
fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c303_l321_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 322
fn c304_l322_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c304_l322_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 323
fn c305_l323_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c305_l323_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 324
fn c306_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c306_l324_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 325
fn c307_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c307_l325_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 326
fn c308_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c308_l326_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 327
fn c309_l327_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c309_l327_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 328
fn c310_l328_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c310_l328_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c310_l328_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 329
fn c311_l329_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c311_l329_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c311_l329_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 330
fn c312_l330_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c312_l330_action_invoke");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 331
fn c313_l331_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c313_l331_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c313_l331_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 332
fn c314_l332_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c314_l332_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c314_l332_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 333
fn c315_l333_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c315_l333_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c315_l333_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 334
fn c316_l334_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c316_l334_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c316_l334_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 335
fn c317_l335_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c317_l335_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c317_l335_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 336
fn c318_l336_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c318_l336_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c318_l336_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 337
fn c319_l337_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c319_l337_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c319_l337_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 338
fn c320_l338_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c320_l338_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c320_l338_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 339
fn c321_l339_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c321_l339_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c321_l339_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 340
fn c322_l340_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c322_l340_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c322_l340_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 341
fn c323_l341_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c323_l341_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c323_l341_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 342
fn c324_l342_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c324_l342_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c324_l342_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 343
fn c325_l343_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c325_l343_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c325_l343_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 344
fn c326_l344_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c326_l344_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c326_l344_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 345
fn c327_l345_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c327_l345_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c327_l345_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 346
fn c328_l346_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c328_l346_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c328_l346_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 347
fn c329_l347_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c329_l347_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c329_l347_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 348
fn c330_l348_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c330_l348_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c330_l348_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 349
fn c331_l349_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c331_l349_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c331_l349_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 350
fn c332_l350_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c332_l350_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c332_l350_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 351
fn c333_l351_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c333_l351_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c333_l351_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 352
fn c334_l352_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c334_l352_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c334_l352_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 353
fn c335_l353_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c335_l353_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c335_l353_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 354
fn c336_l354_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c336_l354_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c336_l354_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 355
fn c337_l355_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c337_l355_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c337_l355_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 356
fn c338_l356_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c338_l356_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c338_l356_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 357
fn c339_l357_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c339_l357_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c339_l357_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 358
fn c340_l358_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c340_l358_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c340_l358_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 359
fn c341_l359_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c341_l359_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c341_l359_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 360
fn c342_l360_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c342_l360_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c342_l360_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 361
fn c343_l361_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c343_l361_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c343_l361_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 362
fn c344_l362_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c344_l362_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c344_l362_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 363
fn c345_l363_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c345_l363_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c345_l363_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 364
fn c346_l364_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c346_l364_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c346_l364_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 365
fn c347_l365_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c347_l365_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c347_l365_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 366
fn c348_l366_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c348_l366_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c348_l366_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 367
fn c349_l367_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c349_l367_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c349_l367_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 368
fn c350_l368_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c350_l368_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c350_l368_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 369
fn c351_l369_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c351_l369_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c351_l369_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 370
fn c352_l370_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c352_l370_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c352_l370_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 371
fn c353_l371_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c353_l371_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c353_l371_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 372
fn c354_l372_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c354_l372_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c354_l372_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 373
fn c355_l373_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c355_l373_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c355_l373_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 374
fn c356_l374_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c356_l374_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c356_l374_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 375
fn c357_l375_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c357_l375_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c357_l375_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 376
fn c358_l376_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c358_l376_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c358_l376_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 377
fn c359_l377_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c359_l377_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c359_l377_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 378
fn c360_l378_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c360_l378_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c360_l378_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 379
fn c361_l379_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c361_l379_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c361_l379_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 380
fn c362_l380_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c362_l380_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c362_l380_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 381
fn c363_l381_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c363_l381_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c363_l381_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 382
fn c364_l382_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c364_l382_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c364_l382_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 383
fn c365_l383_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c365_l383_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c365_l383_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 384
fn c366_l384_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c366_l384_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c366_l384_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 385
fn c367_l385_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c367_l385_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c367_l385_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 386
fn c368_l386_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c368_l386_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c368_l386_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 387
fn c369_l387_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c369_l387_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c369_l387_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 388
fn c370_l388_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c370_l388_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c370_l388_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 389
fn c371_l389_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c371_l389_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c371_l389_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 390
fn c372_l390_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c372_l390_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c372_l390_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 391
fn c373_l391_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c373_l391_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c373_l391_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 392
fn c374_l392_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c374_l392_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c374_l392_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 393
fn c375_l393_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c375_l393_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c375_l393_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 394
fn c376_l394_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c376_l394_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c376_l394_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 395
fn c377_l395_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c377_l395_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c377_l395_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 396
fn c378_l396_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c378_l396_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c378_l396_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 397
fn c379_l397_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c379_l397_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c379_l397_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 398
fn c380_l398_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c380_l398_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c380_l398_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 399
fn c381_l399_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c381_l399_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c381_l399_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 400
fn c382_l400_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c382_l400_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c382_l400_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 401
fn c383_l401_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c383_l401_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c383_l401_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 402
fn c384_l402_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c384_l402_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c384_l402_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 403
fn c385_l403_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c385_l403_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c385_l403_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 404
fn c386_l404_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c386_l404_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c386_l404_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 405
fn c387_l405_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c387_l405_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c387_l405_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 406
fn c388_l406_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c388_l406_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c388_l406_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 407
fn c389_l407_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c389_l407_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c389_l407_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 408
fn c390_l408_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c390_l408_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c390_l408_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 409
fn c391_l409_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c391_l409_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c391_l409_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 410
fn c392_l410_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c392_l410_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c392_l410_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 411
fn c393_l411_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c393_l411_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c393_l411_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 412
fn c394_l412_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c394_l412_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c394_l412_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 413
fn c395_l413_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c395_l413_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c395_l413_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 414
fn c396_l414_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c396_l414_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c396_l414_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 415
fn c397_l415_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c397_l415_assert_return_canonical_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c397_l415_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 416
fn c398_l416_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c398_l416_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c398_l416_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 417
fn c399_l417_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c399_l417_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c399_l417_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 418
fn c400_l418_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c400_l418_assert_return_arithmetic_nan");
    let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c400_l418_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 419
fn c401_l419_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c401_l419_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 420
fn c402_l420_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c402_l420_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 421
fn c403_l421_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c403_l421_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 422
fn c404_l422_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c404_l422_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 423
fn c405_l423_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c405_l423_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 424
fn c406_l424_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c406_l424_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 425
fn c407_l425_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c407_l425_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 426
fn c408_l426_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c408_l426_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 427
fn c409_l427_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c409_l427_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 428
fn c410_l428_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c410_l428_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 429
fn c411_l429_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c411_l429_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 430
fn c412_l430_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c412_l430_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 431
fn c413_l431_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c413_l431_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 432
fn c414_l432_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c414_l432_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 433
fn c415_l433_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c415_l433_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 434
fn c416_l434_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c416_l434_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 435
fn c417_l435_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c417_l435_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 436
fn c418_l436_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c418_l436_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 437
fn c419_l437_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c419_l437_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 438
fn c420_l438_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c420_l438_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 439
fn c421_l439_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c421_l439_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 440
fn c422_l440_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c422_l440_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 441
fn c423_l441_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c423_l441_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 442
fn c424_l442_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c424_l442_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 443
fn c425_l443_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c425_l443_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 444
fn c426_l444_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c426_l444_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 445
fn c427_l445_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c427_l445_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 446
fn c428_l446_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c428_l446_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 447
fn c429_l447_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c429_l447_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 448
fn c430_l448_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c430_l448_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 449
fn c431_l449_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c431_l449_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 450
fn c432_l450_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c432_l450_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 451
fn c433_l451_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c433_l451_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c433_l451_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 452
fn c434_l452_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c434_l452_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c434_l452_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 453
fn c435_l453_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c435_l453_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c435_l453_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 454
fn c436_l454_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c436_l454_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c436_l454_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 455
fn c437_l455_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c437_l455_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c437_l455_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 456
fn c438_l456_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c438_l456_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c438_l456_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 457
fn c439_l457_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c439_l457_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c439_l457_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 458
fn c440_l458_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c440_l458_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c440_l458_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 459
fn c441_l459_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c441_l459_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 460
fn c442_l460_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c442_l460_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 461
fn c443_l461_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c443_l461_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 462
fn c444_l462_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c444_l462_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 463
fn c445_l463_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c445_l463_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 464
fn c446_l464_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c446_l464_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits()))));
    result.map(|_| ())
}

// Line 465
fn c447_l465_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c447_l465_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits()))));
    result.map(|_| ())
}

// Line 466
fn c448_l466_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c448_l466_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 467
fn c449_l467_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c449_l467_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 468
fn c450_l468_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c450_l468_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32).to_bits()))));
    result.map(|_| ())
}

// Line 469
fn c451_l469_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c451_l469_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32).to_bits()))));
    result.map(|_| ())
}

// Line 470
fn c452_l470_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c452_l470_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 471
fn c453_l471_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c453_l471_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 472
fn c454_l472_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c454_l472_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 473
fn c455_l473_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c455_l473_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 474
fn c456_l474_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c456_l474_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 475
fn c457_l475_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c457_l475_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 476
fn c458_l476_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c458_l476_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 477
fn c459_l477_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c459_l477_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 478
fn c460_l478_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c460_l478_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 479
fn c461_l479_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c461_l479_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 480
fn c462_l480_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c462_l480_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 481
fn c463_l481_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c463_l481_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 482
fn c464_l482_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c464_l482_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 483
fn c465_l483_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c465_l483_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 484
fn c466_l484_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c466_l484_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 485
fn c467_l485_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c467_l485_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 486
fn c468_l486_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c468_l486_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 487
fn c469_l487_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c469_l487_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 488
fn c470_l488_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c470_l488_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 489
fn c471_l489_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c471_l489_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 490
fn c472_l490_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c472_l490_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 491
fn c473_l491_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c473_l491_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c473_l491_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 492
fn c474_l492_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c474_l492_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c474_l492_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 493
fn c475_l493_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c475_l493_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c475_l493_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 494
fn c476_l494_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c476_l494_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c476_l494_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 495
fn c477_l495_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c477_l495_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c477_l495_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 496
fn c478_l496_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c478_l496_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c478_l496_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 497
fn c479_l497_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c479_l497_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c479_l497_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 498
fn c480_l498_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c480_l498_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c480_l498_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 499
fn c481_l499_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c481_l499_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 500
fn c482_l500_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c482_l500_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 501
fn c483_l501_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c483_l501_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 502
fn c484_l502_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c484_l502_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 503
fn c485_l503_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c485_l503_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 504
fn c486_l504_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c486_l504_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32).to_bits()))));
    result.map(|_| ())
}

// Line 505
fn c487_l505_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c487_l505_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32).to_bits()))));
    result.map(|_| ())
}

// Line 506
fn c488_l506_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c488_l506_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits()))));
    result.map(|_| ())
}

// Line 507
fn c489_l507_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c489_l507_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 508
fn c490_l508_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c490_l508_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32).to_bits()))));
    result.map(|_| ())
}

// Line 509
fn c491_l509_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c491_l509_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits()))));
    result.map(|_| ())
}

// Line 510
fn c492_l510_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c492_l510_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 511
fn c493_l511_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c493_l511_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 512
fn c494_l512_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c494_l512_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 513
fn c495_l513_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c495_l513_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 514
fn c496_l514_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c496_l514_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 515
fn c497_l515_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c497_l515_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 516
fn c498_l516_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c498_l516_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 517
fn c499_l517_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c499_l517_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 518
fn c500_l518_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c500_l518_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 519
fn c501_l519_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c501_l519_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 520
fn c502_l520_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c502_l520_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 521
fn c503_l521_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c503_l521_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 522
fn c504_l522_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c504_l522_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 523
fn c505_l523_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c505_l523_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 524
fn c506_l524_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c506_l524_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 525
fn c507_l525_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c507_l525_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 526
fn c508_l526_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c508_l526_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 527
fn c509_l527_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c509_l527_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 528
fn c510_l528_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c510_l528_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 529
fn c511_l529_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c511_l529_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 530
fn c512_l530_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c512_l530_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 531
fn c513_l531_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c513_l531_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c513_l531_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 532
fn c514_l532_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c514_l532_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c514_l532_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 533
fn c515_l533_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c515_l533_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c515_l533_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 534
fn c516_l534_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c516_l534_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c516_l534_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 535
fn c517_l535_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c517_l535_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c517_l535_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 536
fn c518_l536_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c518_l536_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c518_l536_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 537
fn c519_l537_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c519_l537_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c519_l537_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 538
fn c520_l538_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c520_l538_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c520_l538_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 539
fn c521_l539_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c521_l539_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 540
fn c522_l540_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c522_l540_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 541
fn c523_l541_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c523_l541_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 542
fn c524_l542_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c524_l542_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 543
fn c525_l543_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c525_l543_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 544
fn c526_l544_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c526_l544_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 545
fn c527_l545_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c527_l545_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 546
fn c528_l546_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c528_l546_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 547
fn c529_l547_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c529_l547_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 548
fn c530_l548_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c530_l548_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 549
fn c531_l549_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c531_l549_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 550
fn c532_l550_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c532_l550_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 551
fn c533_l551_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c533_l551_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 552
fn c534_l552_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c534_l552_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 553
fn c535_l553_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c535_l553_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 554
fn c536_l554_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c536_l554_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 555
fn c537_l555_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c537_l555_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 556
fn c538_l556_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c538_l556_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 557
fn c539_l557_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c539_l557_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 558
fn c540_l558_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c540_l558_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 559
fn c541_l559_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c541_l559_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 560
fn c542_l560_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c542_l560_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 561
fn c543_l561_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c543_l561_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 562
fn c544_l562_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c544_l562_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-5.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 563
fn c545_l563_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c545_l563_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 564
fn c546_l564_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c546_l564_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 565
fn c547_l565_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c547_l565_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 566
fn c548_l566_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c548_l566_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 567
fn c549_l567_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c549_l567_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 568
fn c550_l568_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c550_l568_action_invoke");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 569
fn c551_l569_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c551_l569_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 570
fn c552_l570_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c552_l570_action_invoke");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 571
fn c553_l571_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c553_l571_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c553_l571_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 572
fn c554_l572_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c554_l572_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c554_l572_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 573
fn c555_l573_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c555_l573_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c555_l573_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 574
fn c556_l574_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c556_l574_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c556_l574_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 575
fn c557_l575_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c557_l575_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c557_l575_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 576
fn c558_l576_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c558_l576_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c558_l576_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 577
fn c559_l577_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c559_l577_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c559_l577_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 578
fn c560_l578_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c560_l578_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c560_l578_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 579
fn c561_l579_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c561_l579_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 580
fn c562_l580_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c562_l580_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 581
fn c563_l581_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c563_l581_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 582
fn c564_l582_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c564_l582_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 583
fn c565_l583_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c565_l583_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 584
fn c566_l584_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c566_l584_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 585
fn c567_l585_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c567_l585_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 586
fn c568_l586_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c568_l586_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 587
fn c569_l587_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c569_l587_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 588
fn c570_l588_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c570_l588_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 589
fn c571_l589_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c571_l589_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 590
fn c572_l590_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c572_l590_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 591
fn c573_l591_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c573_l591_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 592
fn c574_l592_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c574_l592_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 593
fn c575_l593_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c575_l593_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 594
fn c576_l594_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c576_l594_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 595
fn c577_l595_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c577_l595_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 596
fn c578_l596_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c578_l596_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 597
fn c579_l597_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c579_l597_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 598
fn c580_l598_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c580_l598_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 599
fn c581_l599_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c581_l599_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 600
fn c582_l600_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c582_l600_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-7.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 601
fn c583_l601_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c583_l601_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((7.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 602
fn c584_l602_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c584_l602_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-5.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 603
fn c585_l603_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c585_l603_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 604
fn c586_l604_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c586_l604_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 605
fn c587_l605_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c587_l605_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 606
fn c588_l606_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c588_l606_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 607
fn c589_l607_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c589_l607_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 608
fn c590_l608_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c590_l608_action_invoke");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 609
fn c591_l609_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c591_l609_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 610
fn c592_l610_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c592_l610_action_invoke");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 611
fn c593_l611_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c593_l611_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c593_l611_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 612
fn c594_l612_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c594_l612_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c594_l612_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 613
fn c595_l613_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c595_l613_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c595_l613_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 614
fn c596_l614_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c596_l614_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c596_l614_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 615
fn c597_l615_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c597_l615_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c597_l615_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 616
fn c598_l616_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c598_l616_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c598_l616_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 617
fn c599_l617_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c599_l617_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c599_l617_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 618
fn c600_l618_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c600_l618_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c600_l618_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 619
fn c601_l619_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c601_l619_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 620
fn c602_l620_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c602_l620_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 621
fn c603_l621_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c603_l621_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 622
fn c604_l622_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c604_l622_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 623
fn c605_l623_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c605_l623_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 624
fn c606_l624_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c606_l624_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 625
fn c607_l625_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c607_l625_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 626
fn c608_l626_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c608_l626_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 627
fn c609_l627_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c609_l627_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 628
fn c610_l628_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c610_l628_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 629
fn c611_l629_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c611_l629_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 630
fn c612_l630_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c612_l630_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 631
fn c613_l631_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c613_l631_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-5.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 632
fn c614_l632_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c614_l632_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 633
fn c615_l633_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c615_l633_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 634
fn c616_l634_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c616_l634_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5.7831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 635
fn c617_l635_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c617_l635_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-5.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 636
fn c618_l636_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c618_l636_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-7.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 637
fn c619_l637_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c619_l637_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((7.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 638
fn c620_l638_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c620_l638_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((5.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 639
fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c621_l639_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 640
fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c622_l640_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-12.566371f32).to_bits()))));
    result.map(|_| ())
}

// Line 641
fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c623_l641_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((12.566371f32).to_bits()))));
    result.map(|_| ())
}

// Line 642
fn c624_l642_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c624_l642_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 643
fn c625_l643_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c625_l643_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 644
fn c626_l644_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c626_l644_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 645
fn c627_l645_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c627_l645_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 646
fn c628_l646_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c628_l646_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 647
fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c629_l647_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 648
fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c630_l648_action_invoke");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 649
fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c631_l649_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 650
fn c632_l650_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c632_l650_action_invoke");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 651
fn c633_l651_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c633_l651_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c633_l651_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 652
fn c634_l652_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c634_l652_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c634_l652_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 653
fn c635_l653_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c635_l653_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c635_l653_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 654
fn c636_l654_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c636_l654_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c636_l654_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 655
fn c637_l655_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c637_l655_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c637_l655_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 656
fn c638_l656_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c638_l656_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c638_l656_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 657
fn c639_l657_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c639_l657_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c639_l657_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 658
fn c640_l658_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c640_l658_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c640_l658_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 659
fn c641_l659_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c641_l659_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 660
fn c642_l660_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c642_l660_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 661
fn c643_l661_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c643_l661_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 662
fn c644_l662_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c644_l662_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 663
fn c645_l663_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c645_l663_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 664
fn c646_l664_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c646_l664_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 665
fn c647_l665_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c647_l665_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 666
fn c648_l666_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c648_l666_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 667
fn c649_l667_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c649_l667_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 668
fn c650_l668_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c650_l668_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 669
fn c651_l669_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c651_l669_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 670
fn c652_l670_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c652_l670_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 671
fn c653_l671_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c653_l671_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 672
fn c654_l672_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c654_l672_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 673
fn c655_l673_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c655_l673_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 674
fn c656_l674_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c656_l674_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 675
fn c657_l675_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c657_l675_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 676
fn c658_l676_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c658_l676_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 677
fn c659_l677_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c659_l677_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 678
fn c660_l678_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c660_l678_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 679
fn c661_l679_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c661_l679_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 680
fn c662_l680_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c662_l680_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 681
fn c663_l681_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c663_l681_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 682
fn c664_l682_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c664_l682_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 683
fn c665_l683_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c665_l683_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 684
fn c666_l684_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c666_l684_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 685
fn c667_l685_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c667_l685_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 686
fn c668_l686_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c668_l686_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 687
fn c669_l687_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c669_l687_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 688
fn c670_l688_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c670_l688_action_invoke");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 689
fn c671_l689_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c671_l689_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 690
fn c672_l690_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c672_l690_action_invoke");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 691
fn c673_l691_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c673_l691_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c673_l691_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 692
fn c674_l692_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c674_l692_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c674_l692_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 693
fn c675_l693_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c675_l693_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c675_l693_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 694
fn c676_l694_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c676_l694_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c676_l694_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 695
fn c677_l695_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c677_l695_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c677_l695_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 696
fn c678_l696_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c678_l696_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c678_l696_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 697
fn c679_l697_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c679_l697_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c679_l697_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 698
fn c680_l698_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c680_l698_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c680_l698_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 699
fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c681_l699_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 700
fn c682_l700_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c682_l700_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 701
fn c683_l701_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c683_l701_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 702
fn c684_l702_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c684_l702_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 703
fn c685_l703_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c685_l703_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 704
fn c686_l704_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c686_l704_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 705
fn c687_l705_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c687_l705_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 706
fn c688_l706_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c688_l706_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 707
fn c689_l707_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c689_l707_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 708
fn c690_l708_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c690_l708_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 709
fn c691_l709_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c691_l709_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 710
fn c692_l710_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c692_l710_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 711
fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c693_l711_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 712
fn c694_l712_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c694_l712_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 713
fn c695_l713_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c695_l713_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 714
fn c696_l714_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c696_l714_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 715
fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c697_l715_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 716
fn c698_l716_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c698_l716_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 717
fn c699_l717_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c699_l717_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 718
fn c700_l718_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c700_l718_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 719
fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c701_l719_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 720
fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c702_l720_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 721
fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c703_l721_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 722
fn c704_l722_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c704_l722_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 723
fn c705_l723_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c705_l723_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 724
fn c706_l724_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c706_l724_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 725
fn c707_l725_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c707_l725_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 726
fn c708_l726_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c708_l726_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 727
fn c709_l727_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c709_l727_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c709_l727_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 728
fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c710_l728_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 729
fn c711_l729_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c711_l729_action_invoke");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 730
fn c712_l730_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c712_l730_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c712_l730_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 731
fn c713_l731_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c713_l731_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c713_l731_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 732
fn c714_l732_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c714_l732_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c714_l732_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 733
fn c715_l733_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c715_l733_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c715_l733_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 734
fn c716_l734_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c716_l734_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c716_l734_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 735
fn c717_l735_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c717_l735_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c717_l735_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 736
fn c718_l736_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c718_l736_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c718_l736_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 737
fn c719_l737_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c719_l737_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c719_l737_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 738
fn c720_l738_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c720_l738_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c720_l738_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 739
fn c721_l739_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c721_l739_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c721_l739_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 740
fn c722_l740_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c722_l740_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c722_l740_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 741
fn c723_l741_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c723_l741_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c723_l741_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 742
fn c724_l742_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c724_l742_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c724_l742_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 743
fn c725_l743_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c725_l743_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c725_l743_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 744
fn c726_l744_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c726_l744_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c726_l744_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 745
fn c727_l745_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c727_l745_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c727_l745_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 746
fn c728_l746_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c728_l746_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c728_l746_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 747
fn c729_l747_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c729_l747_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c729_l747_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 748
fn c730_l748_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c730_l748_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c730_l748_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 749
fn c731_l749_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c731_l749_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c731_l749_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 750
fn c732_l750_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c732_l750_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c732_l750_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 751
fn c733_l751_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c733_l751_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c733_l751_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 752
fn c734_l752_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c734_l752_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c734_l752_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 753
fn c735_l753_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c735_l753_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c735_l753_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 754
fn c736_l754_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c736_l754_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c736_l754_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 755
fn c737_l755_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c737_l755_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c737_l755_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 756
fn c738_l756_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c738_l756_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c738_l756_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 757
fn c739_l757_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c739_l757_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c739_l757_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 758
fn c740_l758_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c740_l758_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c740_l758_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 759
fn c741_l759_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c741_l759_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c741_l759_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 760
fn c742_l760_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c742_l760_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c742_l760_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 761
fn c743_l761_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c743_l761_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c743_l761_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 762
fn c744_l762_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c744_l762_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c744_l762_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 763
fn c745_l763_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c745_l763_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c745_l763_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 764
fn c746_l764_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c746_l764_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c746_l764_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 765
fn c747_l765_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c747_l765_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c747_l765_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 766
fn c748_l766_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c748_l766_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c748_l766_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 767
fn c749_l767_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c749_l767_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c749_l767_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 768
fn c750_l768_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c750_l768_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c750_l768_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 769
fn c751_l769_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c751_l769_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c751_l769_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 770
fn c752_l770_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c752_l770_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c752_l770_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 771
fn c753_l771_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c753_l771_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c753_l771_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 772
fn c754_l772_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c754_l772_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c754_l772_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 773
fn c755_l773_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c755_l773_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c755_l773_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 774
fn c756_l774_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c756_l774_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c756_l774_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 775
fn c757_l775_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c757_l775_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c757_l775_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 776
fn c758_l776_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c758_l776_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c758_l776_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 777
fn c759_l777_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c759_l777_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c759_l777_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 778
fn c760_l778_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c760_l778_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c760_l778_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 779
fn c761_l779_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c761_l779_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c761_l779_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 780
fn c762_l780_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c762_l780_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c762_l780_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 781
fn c763_l781_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c763_l781_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c763_l781_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 782
fn c764_l782_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c764_l782_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c764_l782_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 783
fn c765_l783_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c765_l783_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c765_l783_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 784
fn c766_l784_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c766_l784_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c766_l784_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 785
fn c767_l785_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c767_l785_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c767_l785_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 786
fn c768_l786_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c768_l786_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c768_l786_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 787
fn c769_l787_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c769_l787_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c769_l787_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 788
fn c770_l788_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c770_l788_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c770_l788_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 789
fn c771_l789_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c771_l789_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c771_l789_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 790
fn c772_l790_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c772_l790_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c772_l790_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 791
fn c773_l791_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c773_l791_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c773_l791_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 792
fn c774_l792_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c774_l792_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c774_l792_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 793
fn c775_l793_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c775_l793_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c775_l793_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 794
fn c776_l794_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c776_l794_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c776_l794_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 795
fn c777_l795_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c777_l795_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c777_l795_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 796
fn c778_l796_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c778_l796_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c778_l796_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 797
fn c779_l797_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c779_l797_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c779_l797_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 798
fn c780_l798_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c780_l798_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c780_l798_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 799
fn c781_l799_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c781_l799_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c781_l799_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 800
fn c782_l800_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c782_l800_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c782_l800_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 801
fn c783_l801_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c783_l801_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c783_l801_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 802
fn c784_l802_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c784_l802_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c784_l802_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 803
fn c785_l803_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c785_l803_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c785_l803_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 804
fn c786_l804_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c786_l804_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c786_l804_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 805
fn c787_l805_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c787_l805_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c787_l805_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 806
fn c788_l806_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c788_l806_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c788_l806_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 807
fn c789_l807_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c789_l807_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c789_l807_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 808
fn c790_l808_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c790_l808_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c790_l808_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 809
fn c791_l809_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c791_l809_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c791_l809_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 810
fn c792_l810_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c792_l810_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c792_l810_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 811
fn c793_l811_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c793_l811_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c793_l811_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 812
fn c794_l812_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c794_l812_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c794_l812_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 813
fn c795_l813_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c795_l813_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c795_l813_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 814
fn c796_l814_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c796_l814_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c796_l814_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 815
fn c797_l815_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c797_l815_assert_return_canonical_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c797_l815_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 816
fn c798_l816_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c798_l816_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c798_l816_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 817
fn c799_l817_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c799_l817_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c799_l817_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 818
fn c800_l818_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c800_l818_assert_return_arithmetic_nan");
    let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c800_l818_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 819
fn c801_l819_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c801_l819_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 820
fn c802_l820_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c802_l820_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 821
fn c803_l821_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c803_l821_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 822
fn c804_l822_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c804_l822_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 823
fn c805_l823_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c805_l823_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 824
fn c806_l824_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c806_l824_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 825
fn c807_l825_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c807_l825_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 826
fn c808_l826_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c808_l826_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 827
fn c809_l827_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c809_l827_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 828
fn c810_l828_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c810_l828_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 829
fn c811_l829_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c811_l829_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 830
fn c812_l830_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c812_l830_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 831
fn c813_l831_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c813_l831_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 832
fn c814_l832_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c814_l832_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 833
fn c815_l833_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c815_l833_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 834
fn c816_l834_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c816_l834_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 835
fn c817_l835_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c817_l835_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 836
fn c818_l836_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c818_l836_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 837
fn c819_l837_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c819_l837_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 838
fn c820_l838_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c820_l838_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 839
fn c821_l839_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c821_l839_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 840
fn c822_l840_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c822_l840_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 841
fn c823_l841_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c823_l841_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 842
fn c824_l842_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c824_l842_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 843
fn c825_l843_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c825_l843_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 844
fn c826_l844_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c826_l844_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 845
fn c827_l845_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c827_l845_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 846
fn c828_l846_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c828_l846_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 847
fn c829_l847_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c829_l847_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c829_l847_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 848
fn c830_l848_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c830_l848_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c830_l848_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 849
fn c831_l849_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c831_l849_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c831_l849_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 850
fn c832_l850_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c832_l850_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c832_l850_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 851
fn c833_l851_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c833_l851_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c833_l851_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 852
fn c834_l852_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c834_l852_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c834_l852_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 853
fn c835_l853_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c835_l853_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c835_l853_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 854
fn c836_l854_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c836_l854_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c836_l854_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 855
fn c837_l855_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c837_l855_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c837_l855_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 856
fn c838_l856_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c838_l856_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c838_l856_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 857
fn c839_l857_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c839_l857_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c839_l857_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 858
fn c840_l858_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c840_l858_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c840_l858_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 859
fn c841_l859_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c841_l859_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 860
fn c842_l860_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c842_l860_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 861
fn c843_l861_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c843_l861_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 862
fn c844_l862_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c844_l862_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 863
fn c845_l863_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c845_l863_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 864
fn c846_l864_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c846_l864_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 865
fn c847_l865_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c847_l865_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 866
fn c848_l866_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c848_l866_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 867
fn c849_l867_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c849_l867_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 868
fn c850_l868_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c850_l868_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 869
fn c851_l869_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c851_l869_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 870
fn c852_l870_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c852_l870_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 871
fn c853_l871_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c853_l871_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 872
fn c854_l872_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c854_l872_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 873
fn c855_l873_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c855_l873_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 874
fn c856_l874_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c856_l874_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 875
fn c857_l875_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c857_l875_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 876
fn c858_l876_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c858_l876_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 877
fn c859_l877_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c859_l877_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 878
fn c860_l878_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c860_l878_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 879
fn c861_l879_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c861_l879_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32).to_bits()))));
    result.map(|_| ())
}

// Line 880
fn c862_l880_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c862_l880_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32).to_bits()))));
    result.map(|_| ())
}

// Line 881
fn c863_l881_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c863_l881_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32).to_bits()))));
    result.map(|_| ())
}

// Line 882
fn c864_l882_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c864_l882_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32).to_bits()))));
    result.map(|_| ())
}

// Line 883
fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c865_l883_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32).to_bits()))));
    result.map(|_| ())
}

// Line 884
fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c866_l884_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32).to_bits()))));
    result.map(|_| ())
}

// Line 885
fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c867_l885_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32).to_bits()))));
    result.map(|_| ())
}

// Line 886
fn c868_l886_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c868_l886_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32).to_bits()))));
    result.map(|_| ())
}

// Line 887
fn c869_l887_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c869_l887_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 888
fn c870_l888_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c870_l888_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 889
fn c871_l889_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c871_l889_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 890
fn c872_l890_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c872_l890_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 891
fn c873_l891_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c873_l891_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c873_l891_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 892
fn c874_l892_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c874_l892_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c874_l892_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 893
fn c875_l893_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c875_l893_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c875_l893_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 894
fn c876_l894_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c876_l894_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c876_l894_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 895
fn c877_l895_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c877_l895_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c877_l895_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 896
fn c878_l896_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c878_l896_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c878_l896_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 897
fn c879_l897_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c879_l897_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c879_l897_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 898
fn c880_l898_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c880_l898_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c880_l898_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 899
fn c881_l899_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c881_l899_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 900
fn c882_l900_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c882_l900_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 901
fn c883_l901_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c883_l901_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 902
fn c884_l902_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c884_l902_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 903
fn c885_l903_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c885_l903_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 904
fn c886_l904_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c886_l904_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 905
fn c887_l905_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c887_l905_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 906
fn c888_l906_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c888_l906_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 907
fn c889_l907_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c889_l907_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 908
fn c890_l908_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c890_l908_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 909
fn c891_l909_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c891_l909_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 910
fn c892_l910_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c892_l910_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 911
fn c893_l911_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c893_l911_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32).to_bits()))));
    result.map(|_| ())
}

// Line 912
fn c894_l912_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c894_l912_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32).to_bits()))));
    result.map(|_| ())
}

// Line 913
fn c895_l913_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c895_l913_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32).to_bits()))));
    result.map(|_| ())
}

// Line 914
fn c896_l914_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c896_l914_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32).to_bits()))));
    result.map(|_| ())
}

// Line 915
fn c897_l915_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c897_l915_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 916
fn c898_l916_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c898_l916_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 917
fn c899_l917_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c899_l917_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 918
fn c900_l918_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c900_l918_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 919
fn c901_l919_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c901_l919_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32).to_bits()))));
    result.map(|_| ())
}

// Line 920
fn c902_l920_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c902_l920_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32).to_bits()))));
    result.map(|_| ())
}

// Line 921
fn c903_l921_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c903_l921_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32).to_bits()))));
    result.map(|_| ())
}

// Line 922
fn c904_l922_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c904_l922_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32).to_bits()))));
    result.map(|_| ())
}

// Line 923
fn c905_l923_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c905_l923_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 924
fn c906_l924_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c906_l924_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 925
fn c907_l925_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c907_l925_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 926
fn c908_l926_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c908_l926_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 927
fn c909_l927_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c909_l927_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 928
fn c910_l928_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c910_l928_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 929
fn c911_l929_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c911_l929_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 930
fn c912_l930_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c912_l930_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 931
fn c913_l931_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c913_l931_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c913_l931_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 932
fn c914_l932_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c914_l932_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c914_l932_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 933
fn c915_l933_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c915_l933_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c915_l933_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 934
fn c916_l934_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c916_l934_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c916_l934_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 935
fn c917_l935_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c917_l935_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c917_l935_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 936
fn c918_l936_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c918_l936_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c918_l936_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 937
fn c919_l937_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c919_l937_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c919_l937_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 938
fn c920_l938_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c920_l938_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c920_l938_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 939
fn c921_l939_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c921_l939_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 940
fn c922_l940_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c922_l940_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 941
fn c923_l941_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c923_l941_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 942
fn c924_l942_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c924_l942_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 943
fn c925_l943_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c925_l943_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 944
fn c926_l944_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c926_l944_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 945
fn c927_l945_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c927_l945_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 946
fn c928_l946_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c928_l946_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 947
fn c929_l947_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c929_l947_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32).to_bits()))));
    result.map(|_| ())
}

// Line 948
fn c930_l948_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c930_l948_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32).to_bits()))));
    result.map(|_| ())
}

// Line 949
fn c931_l949_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c931_l949_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32).to_bits()))));
    result.map(|_| ())
}

// Line 950
fn c932_l950_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c932_l950_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32).to_bits()))));
    result.map(|_| ())
}

// Line 951
fn c933_l951_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c933_l951_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.25f32).to_bits()))));
    result.map(|_| ())
}

// Line 952
fn c934_l952_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c934_l952_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.25f32).to_bits()))));
    result.map(|_| ())
}

// Line 953
fn c935_l953_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c935_l953_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.25f32).to_bits()))));
    result.map(|_| ())
}

// Line 954
fn c936_l954_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c936_l954_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.25f32).to_bits()))));
    result.map(|_| ())
}

// Line 955
fn c937_l955_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c937_l955_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 956
fn c938_l956_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c938_l956_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 957
fn c939_l957_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c939_l957_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 958
fn c940_l958_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c940_l958_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 959
fn c941_l959_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c941_l959_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3.1415927f32).to_bits()))));
    result.map(|_| ())
}

// Line 960
fn c942_l960_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c942_l960_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3.1415927f32).to_bits()))));
    result.map(|_| ())
}

// Line 961
fn c943_l961_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c943_l961_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3.1415927f32).to_bits()))));
    result.map(|_| ())
}

// Line 962
fn c944_l962_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c944_l962_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3.1415927f32).to_bits()))));
    result.map(|_| ())
}

// Line 963
fn c945_l963_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c945_l963_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 964
fn c946_l964_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c946_l964_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 965
fn c947_l965_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c947_l965_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 966
fn c948_l966_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c948_l966_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 967
fn c949_l967_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c949_l967_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 968
fn c950_l968_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c950_l968_action_invoke");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 969
fn c951_l969_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c951_l969_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 970
fn c952_l970_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c952_l970_action_invoke");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 971
fn c953_l971_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c953_l971_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c953_l971_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 972
fn c954_l972_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c954_l972_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c954_l972_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 973
fn c955_l973_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c955_l973_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c955_l973_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 974
fn c956_l974_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c956_l974_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c956_l974_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 975
fn c957_l975_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c957_l975_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c957_l975_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 976
fn c958_l976_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c958_l976_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c958_l976_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 977
fn c959_l977_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c959_l977_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c959_l977_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 978
fn c960_l978_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c960_l978_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c960_l978_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 979
fn c961_l979_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c961_l979_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 980
fn c962_l980_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c962_l980_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 981
fn c963_l981_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c963_l981_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 982
fn c964_l982_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c964_l982_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 983
fn c965_l983_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c965_l983_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 984
fn c966_l984_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c966_l984_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 985
fn c967_l985_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c967_l985_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 986
fn c968_l986_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c968_l986_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 987
fn c969_l987_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c969_l987_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 988
fn c970_l988_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c970_l988_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 989
fn c971_l989_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c971_l989_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 990
fn c972_l990_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c972_l990_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 991
fn c973_l991_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c973_l991_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 992
fn c974_l992_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c974_l992_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 993
fn c975_l993_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c975_l993_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 994
fn c976_l994_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c976_l994_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 995
fn c977_l995_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c977_l995_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 996
fn c978_l996_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c978_l996_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 997
fn c979_l997_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c979_l997_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 998
fn c980_l998_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c980_l998_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 999
fn c981_l999_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c981_l999_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1000
fn c982_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c982_l1000_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1001
fn c983_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c983_l1001_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1002
fn c984_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c984_l1002_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1003
fn c985_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c985_l1003_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1004
fn c986_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c986_l1004_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1005
fn c987_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c987_l1005_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1006
fn c988_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c988_l1006_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1007
fn c989_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c989_l1007_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1008
fn c990_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c990_l1008_action_invoke");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1009
fn c991_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c991_l1009_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1010
fn c992_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c992_l1010_action_invoke");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1011
fn c993_l1011_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c993_l1011_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c993_l1011_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1012
fn c994_l1012_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c994_l1012_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c994_l1012_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1013
fn c995_l1013_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c995_l1013_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c995_l1013_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1014
fn c996_l1014_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c996_l1014_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c996_l1014_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1015
fn c997_l1015_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c997_l1015_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c997_l1015_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1016
fn c998_l1016_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c998_l1016_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c998_l1016_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1017
fn c999_l1017_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c999_l1017_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c999_l1017_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1018
fn c1000_l1018_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1000_l1018_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1000_l1018_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1019
fn c1001_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1001_l1019_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1020
fn c1002_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1002_l1020_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1021
fn c1003_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1003_l1021_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1022
fn c1004_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1004_l1022_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1023
fn c1005_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1005_l1023_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32).to_bits()))));
    result.map(|_| ())
}

// Line 1024
fn c1006_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1006_l1024_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32).to_bits()))));
    result.map(|_| ())
}

// Line 1025
fn c1007_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1007_l1025_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32).to_bits()))));
    result.map(|_| ())
}

// Line 1026
fn c1008_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1008_l1026_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32).to_bits()))));
    result.map(|_| ())
}

// Line 1027
fn c1009_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1009_l1027_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32).to_bits()))));
    result.map(|_| ())
}

// Line 1028
fn c1010_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1010_l1028_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32).to_bits()))));
    result.map(|_| ())
}

// Line 1029
fn c1011_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1011_l1029_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32).to_bits()))));
    result.map(|_| ())
}

// Line 1030
fn c1012_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1012_l1030_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32).to_bits()))));
    result.map(|_| ())
}

// Line 1031
fn c1013_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1013_l1031_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3.1415927f32).to_bits()))));
    result.map(|_| ())
}

// Line 1032
fn c1014_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1014_l1032_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3.1415927f32).to_bits()))));
    result.map(|_| ())
}

// Line 1033
fn c1015_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1015_l1033_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3.1415927f32).to_bits()))));
    result.map(|_| ())
}

// Line 1034
fn c1016_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1016_l1034_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3.1415927f32).to_bits()))));
    result.map(|_| ())
}

// Line 1035
fn c1017_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1017_l1035_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1036
fn c1018_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1018_l1036_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1037
fn c1019_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1019_l1037_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1038
fn c1020_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1020_l1038_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1039
fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1021_l1039_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((39.47842f32).to_bits()))));
    result.map(|_| ())
}

// Line 1040
fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1022_l1040_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-39.47842f32).to_bits()))));
    result.map(|_| ())
}

// Line 1041
fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1023_l1041_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-39.47842f32).to_bits()))));
    result.map(|_| ())
}

// Line 1042
fn c1024_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1024_l1042_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((39.47842f32).to_bits()))));
    result.map(|_| ())
}

// Line 1043
fn c1025_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1025_l1043_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1044
fn c1026_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1026_l1044_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1045
fn c1027_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1027_l1045_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1046
fn c1028_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1028_l1046_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1047
fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1029_l1047_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1048
fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1030_l1048_action_invoke");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1049
fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1031_l1049_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1050
fn c1032_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1032_l1050_action_invoke");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1051
fn c1033_l1051_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1033_l1051_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1033_l1051_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1052
fn c1034_l1052_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1034_l1052_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1034_l1052_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1053
fn c1035_l1053_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1035_l1053_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1035_l1053_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1054
fn c1036_l1054_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1036_l1054_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1036_l1054_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1055
fn c1037_l1055_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1037_l1055_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1037_l1055_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1056
fn c1038_l1056_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1038_l1056_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1038_l1056_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1057
fn c1039_l1057_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1039_l1057_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1039_l1057_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1058
fn c1040_l1058_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1040_l1058_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1040_l1058_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1059
fn c1041_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1041_l1059_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1060
fn c1042_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1042_l1060_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1061
fn c1043_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1043_l1061_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1062
fn c1044_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1044_l1062_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1063
fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1045_l1063_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32).to_bits()))));
    result.map(|_| ())
}

// Line 1064
fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1046_l1064_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32).to_bits()))));
    result.map(|_| ())
}

// Line 1065
fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1047_l1065_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32).to_bits()))));
    result.map(|_| ())
}

// Line 1066
fn c1048_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1048_l1066_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32).to_bits()))));
    result.map(|_| ())
}

// Line 1067
fn c1049_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1049_l1067_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 1068
fn c1050_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1050_l1068_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 1069
fn c1051_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1051_l1069_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 1070
fn c1052_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1052_l1070_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((3.9999998f32).to_bits()))));
    result.map(|_| ())
}

// Line 1071
fn c1053_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1053_l1071_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1072
fn c1054_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1054_l1072_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1073
fn c1055_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1055_l1073_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1074
fn c1056_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1056_l1074_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1075
fn c1057_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1057_l1075_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1076
fn c1058_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1058_l1076_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1077
fn c1059_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1059_l1077_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1078
fn c1060_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1060_l1078_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1079
fn c1061_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1061_l1079_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1080
fn c1062_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1062_l1080_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1081
fn c1063_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1063_l1081_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1082
fn c1064_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1064_l1082_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1083
fn c1065_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1065_l1083_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1084
fn c1066_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1066_l1084_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1085
fn c1067_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1067_l1085_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1086
fn c1068_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1068_l1086_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1087
fn c1069_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1069_l1087_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1088
fn c1070_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1070_l1088_action_invoke");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1089
fn c1071_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1071_l1089_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1090
fn c1072_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1072_l1090_action_invoke");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1091
fn c1073_l1091_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1073_l1091_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1073_l1091_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1092
fn c1074_l1092_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1074_l1092_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1074_l1092_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1093
fn c1075_l1093_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1075_l1093_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1075_l1093_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1094
fn c1076_l1094_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1076_l1094_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1076_l1094_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1095
fn c1077_l1095_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1077_l1095_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1077_l1095_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1096
fn c1078_l1096_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1078_l1096_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1078_l1096_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1097
fn c1079_l1097_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1079_l1097_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1079_l1097_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1098
fn c1080_l1098_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1080_l1098_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1080_l1098_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1099
fn c1081_l1099_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1081_l1099_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1081_l1099_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1100
fn c1082_l1100_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1082_l1100_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1082_l1100_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1101
fn c1083_l1101_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1083_l1101_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1083_l1101_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1102
fn c1084_l1102_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1084_l1102_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1084_l1102_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1103
fn c1085_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1085_l1103_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1104
fn c1086_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1086_l1104_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1105
fn c1087_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1087_l1105_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1106
fn c1088_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1088_l1106_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1107
fn c1089_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1089_l1107_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1108
fn c1090_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1090_l1108_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1109
fn c1091_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1091_l1109_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1110
fn c1092_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1092_l1110_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1111
fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1093_l1111_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1112
fn c1094_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1094_l1112_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1113
fn c1095_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1095_l1113_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1114
fn c1096_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1096_l1114_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1115
fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1097_l1115_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1116
fn c1098_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1098_l1116_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1117
fn c1099_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1099_l1117_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1118
fn c1100_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1100_l1118_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1119
fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1101_l1119_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1120
fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1102_l1120_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1121
fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1103_l1121_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1122
fn c1104_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1104_l1122_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1123
fn c1105_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1105_l1123_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1124
fn c1106_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1106_l1124_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1125
fn c1107_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1107_l1125_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1126
fn c1108_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1108_l1126_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1127
fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1109_l1127_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1128
fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1110_l1128_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1129
fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1111_l1129_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1130
fn c1112_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1112_l1130_action_invoke");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1131
fn c1113_l1131_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1113_l1131_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1113_l1131_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1132
fn c1114_l1132_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1114_l1132_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1114_l1132_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1133
fn c1115_l1133_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1115_l1133_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1115_l1133_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1134
fn c1116_l1134_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1116_l1134_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1116_l1134_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1135
fn c1117_l1135_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1117_l1135_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1117_l1135_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1136
fn c1118_l1136_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1118_l1136_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1118_l1136_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1137
fn c1119_l1137_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1119_l1137_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1119_l1137_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1138
fn c1120_l1138_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1120_l1138_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1120_l1138_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1139
fn c1121_l1139_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1121_l1139_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1121_l1139_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1140
fn c1122_l1140_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1122_l1140_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1122_l1140_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1141
fn c1123_l1141_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1123_l1141_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1123_l1141_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1142
fn c1124_l1142_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1124_l1142_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1124_l1142_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1143
fn c1125_l1143_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1125_l1143_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1125_l1143_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1144
fn c1126_l1144_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1126_l1144_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1126_l1144_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1145
fn c1127_l1145_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1127_l1145_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1127_l1145_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1146
fn c1128_l1146_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1128_l1146_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1128_l1146_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1147
fn c1129_l1147_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1129_l1147_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1129_l1147_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1148
fn c1130_l1148_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1130_l1148_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1130_l1148_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1149
fn c1131_l1149_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1131_l1149_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1131_l1149_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1150
fn c1132_l1150_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1132_l1150_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1132_l1150_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1151
fn c1133_l1151_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1133_l1151_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1133_l1151_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1152
fn c1134_l1152_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1134_l1152_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1134_l1152_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1153
fn c1135_l1153_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1135_l1153_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1135_l1153_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1154
fn c1136_l1154_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1136_l1154_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1136_l1154_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1155
fn c1137_l1155_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1137_l1155_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1137_l1155_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1156
fn c1138_l1156_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1138_l1156_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1138_l1156_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1157
fn c1139_l1157_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1139_l1157_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1139_l1157_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1158
fn c1140_l1158_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1140_l1158_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1140_l1158_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1159
fn c1141_l1159_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1141_l1159_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1141_l1159_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1160
fn c1142_l1160_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1142_l1160_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1142_l1160_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1161
fn c1143_l1161_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1143_l1161_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1143_l1161_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1162
fn c1144_l1162_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1144_l1162_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1144_l1162_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1163
fn c1145_l1163_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1145_l1163_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1145_l1163_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1164
fn c1146_l1164_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1146_l1164_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1146_l1164_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1165
fn c1147_l1165_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1147_l1165_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1147_l1165_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1166
fn c1148_l1166_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1148_l1166_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1148_l1166_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1167
fn c1149_l1167_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1149_l1167_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1149_l1167_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1168
fn c1150_l1168_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1150_l1168_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1150_l1168_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1169
fn c1151_l1169_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1151_l1169_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1151_l1169_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1170
fn c1152_l1170_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1152_l1170_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1152_l1170_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1171
fn c1153_l1171_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1153_l1171_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1153_l1171_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1172
fn c1154_l1172_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1154_l1172_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1154_l1172_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1173
fn c1155_l1173_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1155_l1173_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1155_l1173_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1174
fn c1156_l1174_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1156_l1174_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1156_l1174_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1175
fn c1157_l1175_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1157_l1175_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1157_l1175_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1176
fn c1158_l1176_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1158_l1176_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1158_l1176_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1177
fn c1159_l1177_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1159_l1177_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1159_l1177_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1178
fn c1160_l1178_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1160_l1178_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1160_l1178_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1179
fn c1161_l1179_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1161_l1179_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1161_l1179_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1180
fn c1162_l1180_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1162_l1180_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1162_l1180_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1181
fn c1163_l1181_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1163_l1181_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1163_l1181_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1182
fn c1164_l1182_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1164_l1182_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1164_l1182_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1183
fn c1165_l1183_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1165_l1183_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1165_l1183_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1184
fn c1166_l1184_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1166_l1184_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1166_l1184_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1185
fn c1167_l1185_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1167_l1185_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1167_l1185_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1186
fn c1168_l1186_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1168_l1186_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1168_l1186_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1187
fn c1169_l1187_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1169_l1187_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1169_l1187_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1188
fn c1170_l1188_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1170_l1188_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1170_l1188_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1189
fn c1171_l1189_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1171_l1189_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1171_l1189_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1190
fn c1172_l1190_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1172_l1190_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1172_l1190_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1191
fn c1173_l1191_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1173_l1191_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1173_l1191_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1192
fn c1174_l1192_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1174_l1192_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1174_l1192_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1193
fn c1175_l1193_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1175_l1193_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1175_l1193_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1194
fn c1176_l1194_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1176_l1194_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1176_l1194_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1195
fn c1177_l1195_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1177_l1195_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1177_l1195_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1196
fn c1178_l1196_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1178_l1196_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1178_l1196_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1197
fn c1179_l1197_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1179_l1197_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1179_l1197_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1198
fn c1180_l1198_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1180_l1198_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1180_l1198_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1199
fn c1181_l1199_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1181_l1199_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1181_l1199_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1200
fn c1182_l1200_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1182_l1200_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1182_l1200_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1201
fn c1183_l1201_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1183_l1201_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1183_l1201_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1202
fn c1184_l1202_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1184_l1202_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1184_l1202_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1203
fn c1185_l1203_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1185_l1203_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1185_l1203_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1204
fn c1186_l1204_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1186_l1204_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1186_l1204_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1205
fn c1187_l1205_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1187_l1205_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1187_l1205_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1206
fn c1188_l1206_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1188_l1206_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1188_l1206_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1207
fn c1189_l1207_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1189_l1207_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1189_l1207_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1208
fn c1190_l1208_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1190_l1208_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1190_l1208_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1209
fn c1191_l1209_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1191_l1209_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1191_l1209_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1210
fn c1192_l1210_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1192_l1210_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1192_l1210_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1211
fn c1193_l1211_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1193_l1211_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1193_l1211_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1212
fn c1194_l1212_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1194_l1212_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1194_l1212_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1213
fn c1195_l1213_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1195_l1213_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1195_l1213_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1214
fn c1196_l1214_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1196_l1214_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1196_l1214_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1215
fn c1197_l1215_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1197_l1215_assert_return_canonical_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1197_l1215_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1216
fn c1198_l1216_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1198_l1216_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1198_l1216_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1217
fn c1199_l1217_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1199_l1217_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1199_l1217_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1218
fn c1200_l1218_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1200_l1218_assert_return_arithmetic_nan");
    let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1200_l1218_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1219
fn c1201_l1219_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1201_l1219_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1201_l1219_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1220
fn c1202_l1220_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1202_l1220_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1202_l1220_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1221
fn c1203_l1221_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1203_l1221_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1203_l1221_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1222
fn c1204_l1222_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1204_l1222_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1204_l1222_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1223
fn c1205_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1205_l1223_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1224
fn c1206_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1206_l1224_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1225
fn c1207_l1225_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1207_l1225_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1226
fn c1208_l1226_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1208_l1226_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1227
fn c1209_l1227_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1209_l1227_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1228
fn c1210_l1228_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1210_l1228_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1229
fn c1211_l1229_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1211_l1229_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1230
fn c1212_l1230_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1212_l1230_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1231
fn c1213_l1231_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1213_l1231_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1232
fn c1214_l1232_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1214_l1232_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1233
fn c1215_l1233_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1215_l1233_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1234
fn c1216_l1234_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1216_l1234_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1235
fn c1217_l1235_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1217_l1235_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1236
fn c1218_l1236_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1218_l1236_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1237
fn c1219_l1237_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1219_l1237_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1238
fn c1220_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1220_l1238_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1239
fn c1221_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1221_l1239_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1240
fn c1222_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1222_l1240_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1241
fn c1223_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1223_l1241_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1242
fn c1224_l1242_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1224_l1242_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1243
fn c1225_l1243_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1225_l1243_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1244
fn c1226_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1226_l1244_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1245
fn c1227_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1227_l1245_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1246
fn c1228_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1228_l1246_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1247
fn c1229_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1229_l1247_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1248
fn c1230_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1230_l1248_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1249
fn c1231_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1231_l1249_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1250
fn c1232_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1232_l1250_action_invoke");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1251
fn c1233_l1251_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1233_l1251_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1233_l1251_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1252
fn c1234_l1252_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1234_l1252_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1234_l1252_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1253
fn c1235_l1253_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1235_l1253_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1235_l1253_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1254
fn c1236_l1254_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1236_l1254_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1236_l1254_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1255
fn c1237_l1255_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1237_l1255_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1237_l1255_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1256
fn c1238_l1256_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1238_l1256_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1238_l1256_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1257
fn c1239_l1257_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1239_l1257_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1239_l1257_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1258
fn c1240_l1258_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1240_l1258_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1240_l1258_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1259
fn c1241_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1241_l1259_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1260
fn c1242_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1242_l1260_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1261
fn c1243_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1243_l1261_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1262
fn c1244_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1244_l1262_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1263
fn c1245_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1245_l1263_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1264
fn c1246_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1246_l1264_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1265
fn c1247_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1247_l1265_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1266
fn c1248_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1248_l1266_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1267
fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1249_l1267_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32).to_bits()))));
    result.map(|_| ())
}

// Line 1268
fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1250_l1268_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32).to_bits()))));
    result.map(|_| ())
}

// Line 1269
fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1251_l1269_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32).to_bits()))));
    result.map(|_| ())
}

// Line 1270
fn c1252_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1252_l1270_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32).to_bits()))));
    result.map(|_| ())
}

// Line 1271
fn c1253_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1253_l1271_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits()))));
    result.map(|_| ())
}

// Line 1272
fn c1254_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1254_l1272_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits()))));
    result.map(|_| ())
}

// Line 1273
fn c1255_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1255_l1273_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits()))));
    result.map(|_| ())
}

// Line 1274
fn c1256_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1256_l1274_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits()))));
    result.map(|_| ())
}

// Line 1275
fn c1257_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1257_l1275_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1276
fn c1258_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1258_l1276_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1277
fn c1259_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1259_l1277_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1278
fn c1260_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1260_l1278_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1279
fn c1261_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1261_l1279_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1280
fn c1262_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1262_l1280_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1281
fn c1263_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1263_l1281_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1282
fn c1264_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1264_l1282_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1283
fn c1265_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1265_l1283_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1284
fn c1266_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1266_l1284_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1285
fn c1267_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1267_l1285_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1286
fn c1268_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1268_l1286_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1287
fn c1269_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1269_l1287_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1288
fn c1270_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1270_l1288_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1289
fn c1271_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1271_l1289_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1290
fn c1272_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1272_l1290_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1291
fn c1273_l1291_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1273_l1291_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1273_l1291_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1292
fn c1274_l1292_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1274_l1292_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1274_l1292_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1293
fn c1275_l1293_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1275_l1293_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1275_l1293_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1294
fn c1276_l1294_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1276_l1294_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1276_l1294_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1295
fn c1277_l1295_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1277_l1295_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1277_l1295_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1296
fn c1278_l1296_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1278_l1296_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1278_l1296_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1297
fn c1279_l1297_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1279_l1297_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1279_l1297_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1298
fn c1280_l1298_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1280_l1298_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1280_l1298_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1299
fn c1281_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1281_l1299_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1300
fn c1282_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1282_l1300_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1301
fn c1283_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1283_l1301_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1302
fn c1284_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1284_l1302_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1303
fn c1285_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1285_l1303_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1304
fn c1286_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1286_l1304_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1305
fn c1287_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1287_l1305_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1306
fn c1288_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1288_l1306_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1307
fn c1289_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1289_l1307_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1308
fn c1290_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1290_l1308_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1309
fn c1291_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1291_l1309_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1310
fn c1292_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1292_l1310_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1311
fn c1293_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1293_l1311_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits()))));
    result.map(|_| ())
}

// Line 1312
fn c1294_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1294_l1312_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32).to_bits()))));
    result.map(|_| ())
}

// Line 1313
fn c1295_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1295_l1313_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32).to_bits()))));
    result.map(|_| ())
}

// Line 1314
fn c1296_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1296_l1314_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits()))));
    result.map(|_| ())
}

// Line 1315
fn c1297_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1297_l1315_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1316
fn c1298_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1298_l1316_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1317
fn c1299_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1299_l1317_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1318
fn c1300_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1300_l1318_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1319
fn c1301_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1301_l1319_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001870857f32).to_bits()))));
    result.map(|_| ())
}

// Line 1320
fn c1302_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1302_l1320_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001870857f32).to_bits()))));
    result.map(|_| ())
}

// Line 1321
fn c1303_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1303_l1321_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001870857f32).to_bits()))));
    result.map(|_| ())
}

// Line 1322
fn c1304_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1304_l1322_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001870857f32).to_bits()))));
    result.map(|_| ())
}

// Line 1323
fn c1305_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1305_l1323_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1324
fn c1306_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1306_l1324_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1325
fn c1307_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1307_l1325_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1326
fn c1308_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1308_l1326_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1327
fn c1309_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1309_l1327_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1328
fn c1310_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1310_l1328_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1329
fn c1311_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1311_l1329_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1330
fn c1312_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1312_l1330_action_invoke");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1331
fn c1313_l1331_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1313_l1331_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1313_l1331_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1332
fn c1314_l1332_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1314_l1332_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1314_l1332_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1333
fn c1315_l1333_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1315_l1333_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1315_l1333_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1334
fn c1316_l1334_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1316_l1334_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1316_l1334_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1335
fn c1317_l1335_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1317_l1335_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1317_l1335_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1336
fn c1318_l1336_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1318_l1336_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1318_l1336_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1337
fn c1319_l1337_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1319_l1337_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1319_l1337_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1338
fn c1320_l1338_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1320_l1338_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1320_l1338_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1339
fn c1321_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1321_l1339_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1340
fn c1322_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1322_l1340_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1341
fn c1323_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1323_l1341_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1342
fn c1324_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1324_l1342_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1343
fn c1325_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1325_l1343_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1344
fn c1326_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1326_l1344_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1345
fn c1327_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1327_l1345_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1346
fn c1328_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1328_l1346_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1347
fn c1329_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1329_l1347_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((42535296000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1348
fn c1330_l1348_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1330_l1348_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-42535296000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1349
fn c1331_l1349_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1331_l1349_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-42535296000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1350
fn c1332_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1332_l1350_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((42535296000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1351
fn c1333_l1351_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1333_l1351_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1352
fn c1334_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1334_l1352_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1353
fn c1335_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1335_l1353_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1354
fn c1336_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1336_l1354_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1355
fn c1337_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1337_l1355_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1356
fn c1338_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1338_l1356_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1357
fn c1339_l1357_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1339_l1357_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1358
fn c1340_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1340_l1358_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1359
fn c1341_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1341_l1359_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.07957747f32).to_bits()))));
    result.map(|_| ())
}

// Line 1360
fn c1342_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1342_l1360_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.07957747f32).to_bits()))));
    result.map(|_| ())
}

// Line 1361
fn c1343_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1343_l1361_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.07957747f32).to_bits()))));
    result.map(|_| ())
}

// Line 1362
fn c1344_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1344_l1362_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.07957747f32).to_bits()))));
    result.map(|_| ())
}

// Line 1363
fn c1345_l1363_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1345_l1363_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001469368f32).to_bits()))));
    result.map(|_| ())
}

// Line 1364
fn c1346_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1346_l1364_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001469368f32).to_bits()))));
    result.map(|_| ())
}

// Line 1365
fn c1347_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1347_l1365_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001469368f32).to_bits()))));
    result.map(|_| ())
}

// Line 1366
fn c1348_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1348_l1366_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001469368f32).to_bits()))));
    result.map(|_| ())
}

// Line 1367
fn c1349_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1349_l1367_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1368
fn c1350_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1350_l1368_action_invoke");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1369
fn c1351_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1351_l1369_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1370
fn c1352_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1352_l1370_action_invoke");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1371
fn c1353_l1371_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1353_l1371_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1353_l1371_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1372
fn c1354_l1372_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1354_l1372_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1354_l1372_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1373
fn c1355_l1373_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1355_l1373_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1355_l1373_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1374
fn c1356_l1374_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1356_l1374_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1356_l1374_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1375
fn c1357_l1375_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1357_l1375_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1357_l1375_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1376
fn c1358_l1376_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1358_l1376_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1358_l1376_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1377
fn c1359_l1377_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1359_l1377_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1359_l1377_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1378
fn c1360_l1378_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1360_l1378_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1360_l1378_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1379
fn c1361_l1379_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1361_l1379_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1380
fn c1362_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1362_l1380_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1381
fn c1363_l1381_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1363_l1381_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1382
fn c1364_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1364_l1382_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1383
fn c1365_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1365_l1383_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1384
fn c1366_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1366_l1384_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1385
fn c1367_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1367_l1385_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1386
fn c1368_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1368_l1386_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1387
fn c1369_l1387_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1369_l1387_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((85070590000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1388
fn c1370_l1388_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1370_l1388_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-85070590000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1389
fn c1371_l1389_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1371_l1389_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-85070590000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1390
fn c1372_l1390_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1372_l1390_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((85070590000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1391
fn c1373_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1373_l1391_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1392
fn c1374_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1374_l1392_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1393
fn c1375_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1375_l1393_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1394
fn c1376_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1376_l1394_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1395
fn c1377_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1377_l1395_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1396
fn c1378_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1378_l1396_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1397
fn c1379_l1397_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1379_l1397_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1398
fn c1380_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1380_l1398_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1399
fn c1381_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1381_l1399_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.15915494f32).to_bits()))));
    result.map(|_| ())
}

// Line 1400
fn c1382_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1382_l1400_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.15915494f32).to_bits()))));
    result.map(|_| ())
}

// Line 1401
fn c1383_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1383_l1401_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.15915494f32).to_bits()))));
    result.map(|_| ())
}

// Line 1402
fn c1384_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1384_l1402_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.15915494f32).to_bits()))));
    result.map(|_| ())
}

// Line 1403
fn c1385_l1403_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1385_l1403_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000002938736f32).to_bits()))));
    result.map(|_| ())
}

// Line 1404
fn c1386_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1386_l1404_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000002938736f32).to_bits()))));
    result.map(|_| ())
}

// Line 1405
fn c1387_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1387_l1405_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000002938736f32).to_bits()))));
    result.map(|_| ())
}

// Line 1406
fn c1388_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1388_l1406_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000002938736f32).to_bits()))));
    result.map(|_| ())
}

// Line 1407
fn c1389_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1389_l1407_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1408
fn c1390_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1390_l1408_action_invoke");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1409
fn c1391_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1391_l1409_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1410
fn c1392_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1392_l1410_action_invoke");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1411
fn c1393_l1411_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1393_l1411_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1393_l1411_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1412
fn c1394_l1412_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1394_l1412_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1394_l1412_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1413
fn c1395_l1413_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1395_l1413_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1395_l1413_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1414
fn c1396_l1414_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1396_l1414_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1396_l1414_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1415
fn c1397_l1415_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1397_l1415_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1397_l1415_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1416
fn c1398_l1416_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1398_l1416_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1398_l1416_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1417
fn c1399_l1417_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1399_l1417_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1399_l1417_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1418
fn c1400_l1418_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1400_l1418_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1400_l1418_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1419
fn c1401_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1401_l1419_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1420
fn c1402_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1402_l1420_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1421
fn c1403_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1403_l1421_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1422
fn c1404_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1404_l1422_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1423
fn c1405_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1405_l1423_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1424
fn c1406_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1406_l1424_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1425
fn c1407_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1407_l1425_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1426
fn c1408_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1408_l1426_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1427
fn c1409_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1409_l1427_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1428
fn c1410_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1410_l1428_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1429
fn c1411_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1411_l1429_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1430
fn c1412_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1412_l1430_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1431
fn c1413_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1413_l1431_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((12.566371f32).to_bits()))));
    result.map(|_| ())
}

// Line 1432
fn c1414_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1414_l1432_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-12.566371f32).to_bits()))));
    result.map(|_| ())
}

// Line 1433
fn c1415_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1415_l1433_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-12.566371f32).to_bits()))));
    result.map(|_| ())
}

// Line 1434
fn c1416_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1416_l1434_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((12.566371f32).to_bits()))));
    result.map(|_| ())
}

// Line 1435
fn c1417_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1417_l1435_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1436
fn c1418_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1418_l1436_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1437
fn c1419_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1419_l1437_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1438
fn c1420_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1420_l1438_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1439
fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1421_l1439_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1440
fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1422_l1440_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1441
fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1423_l1441_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1442
fn c1424_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1424_l1442_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1443
fn c1425_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1425_l1443_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000018464624f32).to_bits()))));
    result.map(|_| ())
}

// Line 1444
fn c1426_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1426_l1444_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000018464624f32).to_bits()))));
    result.map(|_| ())
}

// Line 1445
fn c1427_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1427_l1445_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000018464624f32).to_bits()))));
    result.map(|_| ())
}

// Line 1446
fn c1428_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1428_l1446_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000018464624f32).to_bits()))));
    result.map(|_| ())
}

// Line 1447
fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1429_l1447_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1448
fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1430_l1448_action_invoke");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1449
fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1431_l1449_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1450
fn c1432_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1432_l1450_action_invoke");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1451
fn c1433_l1451_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1433_l1451_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1433_l1451_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1452
fn c1434_l1452_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1434_l1452_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1434_l1452_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1453
fn c1435_l1453_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1435_l1453_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1435_l1453_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1454
fn c1436_l1454_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1436_l1454_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1436_l1454_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1455
fn c1437_l1455_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1437_l1455_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1437_l1455_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1456
fn c1438_l1456_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1438_l1456_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1438_l1456_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1457
fn c1439_l1457_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1439_l1457_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1439_l1457_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1458
fn c1440_l1458_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1440_l1458_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1440_l1458_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1459
fn c1441_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1441_l1459_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1460
fn c1442_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1442_l1460_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1461
fn c1443_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1443_l1461_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1462
fn c1444_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1444_l1462_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1463
fn c1445_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1445_l1463_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1464
fn c1446_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1446_l1464_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1465
fn c1447_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1447_l1465_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1466
fn c1448_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1448_l1466_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1467
fn c1449_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1449_l1467_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1468
fn c1450_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1450_l1468_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1469
fn c1451_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1451_l1469_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1470
fn c1452_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1452_l1470_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1471
fn c1453_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1453_l1471_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1472
fn c1454_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1454_l1472_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1473
fn c1455_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1455_l1473_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1474
fn c1456_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1456_l1474_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1475
fn c1457_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1457_l1475_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1476
fn c1458_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1458_l1476_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1477
fn c1459_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1459_l1477_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1478
fn c1460_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1460_l1478_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1479
fn c1461_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1461_l1479_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((54157613000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1480
fn c1462_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1462_l1480_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-54157613000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1481
fn c1463_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1463_l1481_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-54157613000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1482
fn c1464_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1464_l1482_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((54157613000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1483
fn c1465_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1465_l1483_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1484
fn c1466_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1466_l1484_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1485
fn c1467_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1467_l1485_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1486
fn c1468_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1468_l1486_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1487
fn c1469_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1469_l1487_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1488
fn c1470_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1470_l1488_action_invoke");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1489
fn c1471_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1471_l1489_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1490
fn c1472_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1472_l1490_action_invoke");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1491
fn c1473_l1491_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1473_l1491_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1473_l1491_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1492
fn c1474_l1492_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1474_l1492_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1474_l1492_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1493
fn c1475_l1493_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1475_l1493_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1475_l1493_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1494
fn c1476_l1494_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1476_l1494_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1476_l1494_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1495
fn c1477_l1495_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1477_l1495_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1477_l1495_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1496
fn c1478_l1496_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1478_l1496_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1478_l1496_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1497
fn c1479_l1497_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1479_l1497_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1479_l1497_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1498
fn c1480_l1498_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1480_l1498_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1480_l1498_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1499
fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1481_l1499_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1500
fn c1482_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1482_l1500_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1501
fn c1483_l1501_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1483_l1501_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1502
fn c1484_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1484_l1502_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1503
fn c1485_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1485_l1503_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1504
fn c1486_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1486_l1504_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1505
fn c1487_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1487_l1505_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1506
fn c1488_l1506_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1488_l1506_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1507
fn c1489_l1507_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1489_l1507_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1508
fn c1490_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1490_l1508_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1509
fn c1491_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1491_l1509_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1510
fn c1492_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1492_l1510_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1511
fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1493_l1511_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1512
fn c1494_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1494_l1512_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1513
fn c1495_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1495_l1513_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1514
fn c1496_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1496_l1514_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1515
fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1497_l1515_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1516
fn c1498_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1498_l1516_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1517
fn c1499_l1517_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1499_l1517_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1518
fn c1500_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1500_l1518_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1519
fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1501_l1519_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1520
fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1502_l1520_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1521
fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1503_l1521_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1522
fn c1504_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1504_l1522_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1523
fn c1505_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1505_l1523_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1524
fn c1506_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1506_l1524_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1525
fn c1507_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1507_l1525_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1526
fn c1508_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1508_l1526_action_invoke");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1527
fn c1509_l1527_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1509_l1527_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1509_l1527_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1528
fn c1510_l1528_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1510_l1528_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1510_l1528_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1529
fn c1511_l1529_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1511_l1529_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1511_l1529_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1530
fn c1512_l1530_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1512_l1530_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1512_l1530_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1531
fn c1513_l1531_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1513_l1531_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1513_l1531_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1532
fn c1514_l1532_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1514_l1532_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1514_l1532_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1533
fn c1515_l1533_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1515_l1533_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1515_l1533_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1534
fn c1516_l1534_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1516_l1534_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1516_l1534_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1535
fn c1517_l1535_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1517_l1535_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1517_l1535_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1536
fn c1518_l1536_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1518_l1536_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1518_l1536_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1537
fn c1519_l1537_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1519_l1537_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1519_l1537_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1538
fn c1520_l1538_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1520_l1538_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1520_l1538_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1539
fn c1521_l1539_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1521_l1539_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1521_l1539_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1540
fn c1522_l1540_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1522_l1540_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1522_l1540_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1541
fn c1523_l1541_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1523_l1541_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1523_l1541_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1542
fn c1524_l1542_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1524_l1542_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1524_l1542_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1543
fn c1525_l1543_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1525_l1543_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1525_l1543_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1544
fn c1526_l1544_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1526_l1544_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1526_l1544_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1545
fn c1527_l1545_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1527_l1545_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1527_l1545_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1546
fn c1528_l1546_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1528_l1546_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1528_l1546_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1547
fn c1529_l1547_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1529_l1547_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1529_l1547_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1548
fn c1530_l1548_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1530_l1548_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1530_l1548_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1549
fn c1531_l1549_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1531_l1549_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1531_l1549_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1550
fn c1532_l1550_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1532_l1550_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1532_l1550_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1551
fn c1533_l1551_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1533_l1551_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1533_l1551_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1552
fn c1534_l1552_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1534_l1552_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1534_l1552_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1553
fn c1535_l1553_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1535_l1553_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1535_l1553_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1554
fn c1536_l1554_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1536_l1554_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1536_l1554_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1555
fn c1537_l1555_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1537_l1555_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1537_l1555_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1556
fn c1538_l1556_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1538_l1556_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1538_l1556_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1557
fn c1539_l1557_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1539_l1557_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1539_l1557_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1558
fn c1540_l1558_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1540_l1558_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1540_l1558_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1559
fn c1541_l1559_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1541_l1559_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1541_l1559_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1560
fn c1542_l1560_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1542_l1560_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1542_l1560_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1561
fn c1543_l1561_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1543_l1561_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1543_l1561_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1562
fn c1544_l1562_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1544_l1562_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1544_l1562_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1563
fn c1545_l1563_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1545_l1563_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1545_l1563_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1564
fn c1546_l1564_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1546_l1564_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1546_l1564_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1565
fn c1547_l1565_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1547_l1565_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1547_l1565_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1566
fn c1548_l1566_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1548_l1566_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1548_l1566_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1567
fn c1549_l1567_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1549_l1567_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1549_l1567_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1568
fn c1550_l1568_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1550_l1568_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1550_l1568_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1569
fn c1551_l1569_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1551_l1569_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1551_l1569_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1570
fn c1552_l1570_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1552_l1570_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1552_l1570_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1571
fn c1553_l1571_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1553_l1571_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1553_l1571_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1572
fn c1554_l1572_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1554_l1572_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1554_l1572_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1573
fn c1555_l1573_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1555_l1573_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1555_l1573_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1574
fn c1556_l1574_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1556_l1574_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1556_l1574_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1575
fn c1557_l1575_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1557_l1575_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1557_l1575_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1576
fn c1558_l1576_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1558_l1576_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1558_l1576_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1577
fn c1559_l1577_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1559_l1577_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1559_l1577_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1578
fn c1560_l1578_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1560_l1578_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1560_l1578_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1579
fn c1561_l1579_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1561_l1579_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1561_l1579_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1580
fn c1562_l1580_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1562_l1580_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1562_l1580_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1581
fn c1563_l1581_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1563_l1581_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1563_l1581_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1582
fn c1564_l1582_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1564_l1582_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1564_l1582_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1583
fn c1565_l1583_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1565_l1583_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1565_l1583_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1584
fn c1566_l1584_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1566_l1584_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1566_l1584_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1585
fn c1567_l1585_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1567_l1585_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1567_l1585_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1586
fn c1568_l1586_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1568_l1586_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1568_l1586_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1587
fn c1569_l1587_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1569_l1587_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1569_l1587_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1588
fn c1570_l1588_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1570_l1588_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1570_l1588_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1589
fn c1571_l1589_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1571_l1589_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1571_l1589_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1590
fn c1572_l1590_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1572_l1590_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1572_l1590_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1591
fn c1573_l1591_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1573_l1591_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1573_l1591_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1592
fn c1574_l1592_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1574_l1592_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1574_l1592_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1593
fn c1575_l1593_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1575_l1593_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1575_l1593_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1594
fn c1576_l1594_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1576_l1594_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1576_l1594_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1595
fn c1577_l1595_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1577_l1595_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1577_l1595_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1596
fn c1578_l1596_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1578_l1596_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1578_l1596_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1597
fn c1579_l1597_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1579_l1597_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1579_l1597_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1598
fn c1580_l1598_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1580_l1598_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1580_l1598_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1599
fn c1581_l1599_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1581_l1599_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1581_l1599_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1600
fn c1582_l1600_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1582_l1600_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1582_l1600_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1601
fn c1583_l1601_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1583_l1601_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1583_l1601_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1602
fn c1584_l1602_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1584_l1602_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1584_l1602_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1603
fn c1585_l1603_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1585_l1603_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1585_l1603_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1604
fn c1586_l1604_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1586_l1604_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1586_l1604_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1605
fn c1587_l1605_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1587_l1605_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1587_l1605_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1606
fn c1588_l1606_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1588_l1606_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1588_l1606_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1607
fn c1589_l1607_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1589_l1607_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1589_l1607_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1608
fn c1590_l1608_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1590_l1608_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1590_l1608_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1609
fn c1591_l1609_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1591_l1609_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1591_l1609_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1610
fn c1592_l1610_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1592_l1610_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1592_l1610_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1611
fn c1593_l1611_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1593_l1611_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1593_l1611_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1612
fn c1594_l1612_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1594_l1612_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1594_l1612_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1613
fn c1595_l1613_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1595_l1613_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1595_l1613_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1614
fn c1596_l1614_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1596_l1614_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1596_l1614_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1615
fn c1597_l1615_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1597_l1615_assert_return_canonical_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1597_l1615_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1616
fn c1598_l1616_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1598_l1616_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1598_l1616_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1617
fn c1599_l1617_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1599_l1617_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1599_l1617_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1618
fn c1600_l1618_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1600_l1618_assert_return_arithmetic_nan");
    let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1600_l1618_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1619
fn c1601_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1601_l1619_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1620
fn c1602_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1602_l1620_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1621
fn c1603_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1603_l1621_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1622
fn c1604_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1604_l1622_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1623
fn c1605_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1605_l1623_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1624
fn c1606_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1606_l1624_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1625
fn c1607_l1625_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1607_l1625_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1626
fn c1608_l1626_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1608_l1626_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1627
fn c1609_l1627_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1609_l1627_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1628
fn c1610_l1628_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1610_l1628_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1629
fn c1611_l1629_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1611_l1629_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1630
fn c1612_l1630_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1612_l1630_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1631
fn c1613_l1631_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1613_l1631_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1632
fn c1614_l1632_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1614_l1632_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1633
fn c1615_l1633_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1615_l1633_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1634
fn c1616_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1616_l1634_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1635
fn c1617_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1617_l1635_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1636
fn c1618_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1618_l1636_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1637
fn c1619_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1619_l1637_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1638
fn c1620_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1620_l1638_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1639
fn c1621_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1621_l1639_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1640
fn c1622_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1622_l1640_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1641
fn c1623_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1623_l1641_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1642
fn c1624_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1624_l1642_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1643
fn c1625_l1643_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1625_l1643_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1644
fn c1626_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1626_l1644_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1645
fn c1627_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1627_l1645_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1646
fn c1628_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1628_l1646_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1647
fn c1629_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1629_l1647_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1648
fn c1630_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1630_l1648_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1649
fn c1631_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1631_l1649_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1650
fn c1632_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1632_l1650_action_invoke");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1651
fn c1633_l1651_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1633_l1651_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1633_l1651_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1652
fn c1634_l1652_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1634_l1652_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1634_l1652_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1653
fn c1635_l1653_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1635_l1653_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1635_l1653_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1654
fn c1636_l1654_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1636_l1654_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1636_l1654_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1655
fn c1637_l1655_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1637_l1655_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1637_l1655_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1656
fn c1638_l1656_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1638_l1656_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1638_l1656_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1657
fn c1639_l1657_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1639_l1657_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1639_l1657_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1658
fn c1640_l1658_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1640_l1658_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1640_l1658_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1659
fn c1641_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1641_l1659_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1660
fn c1642_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1642_l1660_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1661
fn c1643_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1643_l1661_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1662
fn c1644_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1644_l1662_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1663
fn c1645_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1645_l1663_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1664
fn c1646_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1646_l1664_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1665
fn c1647_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1647_l1665_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1666
fn c1648_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1648_l1666_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1667
fn c1649_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1649_l1667_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1668
fn c1650_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1650_l1668_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1669
fn c1651_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1651_l1669_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1670
fn c1652_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1652_l1670_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1671
fn c1653_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1653_l1671_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1672
fn c1654_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1654_l1672_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1673
fn c1655_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1655_l1673_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1674
fn c1656_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1656_l1674_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1675
fn c1657_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1657_l1675_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1676
fn c1658_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1658_l1676_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1677
fn c1659_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1659_l1677_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1678
fn c1660_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1660_l1678_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1679
fn c1661_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1661_l1679_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1680
fn c1662_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1662_l1680_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1681
fn c1663_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1663_l1681_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1682
fn c1664_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1664_l1682_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1683
fn c1665_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1665_l1683_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1684
fn c1666_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1666_l1684_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1685
fn c1667_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1667_l1685_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1686
fn c1668_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1668_l1686_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1687
fn c1669_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1669_l1687_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1688
fn c1670_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1670_l1688_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1689
fn c1671_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1671_l1689_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1690
fn c1672_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1672_l1690_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1691
fn c1673_l1691_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1673_l1691_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1673_l1691_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1692
fn c1674_l1692_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1674_l1692_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1674_l1692_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1693
fn c1675_l1693_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1675_l1693_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1675_l1693_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1694
fn c1676_l1694_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1676_l1694_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1676_l1694_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1695
fn c1677_l1695_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1677_l1695_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1677_l1695_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1696
fn c1678_l1696_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1678_l1696_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1678_l1696_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1697
fn c1679_l1697_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1679_l1697_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1679_l1697_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1698
fn c1680_l1698_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1680_l1698_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1680_l1698_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1699
fn c1681_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1681_l1699_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1700
fn c1682_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1682_l1700_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1701
fn c1683_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1683_l1701_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1702
fn c1684_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1684_l1702_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1703
fn c1685_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1685_l1703_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1704
fn c1686_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1686_l1704_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1705
fn c1687_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1687_l1705_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1706
fn c1688_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1688_l1706_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1707
fn c1689_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1689_l1707_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1708
fn c1690_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1690_l1708_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1709
fn c1691_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1691_l1709_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1710
fn c1692_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1692_l1710_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1711
fn c1693_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1693_l1711_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1712
fn c1694_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1694_l1712_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1713
fn c1695_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1695_l1713_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1714
fn c1696_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1696_l1714_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1715
fn c1697_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1697_l1715_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1716
fn c1698_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1698_l1716_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1717
fn c1699_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1699_l1717_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1718
fn c1700_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1700_l1718_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1719
fn c1701_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1701_l1719_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1720
fn c1702_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1702_l1720_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1721
fn c1703_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1703_l1721_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1722
fn c1704_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1704_l1722_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1723
fn c1705_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1705_l1723_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1724
fn c1706_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1706_l1724_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1725
fn c1707_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1707_l1725_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1726
fn c1708_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1708_l1726_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1727
fn c1709_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1709_l1727_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1728
fn c1710_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1710_l1728_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1729
fn c1711_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1711_l1729_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1730
fn c1712_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1712_l1730_action_invoke");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1731
fn c1713_l1731_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1713_l1731_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1713_l1731_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1732
fn c1714_l1732_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1714_l1732_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1714_l1732_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1733
fn c1715_l1733_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1715_l1733_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1715_l1733_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1734
fn c1716_l1734_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1716_l1734_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1716_l1734_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1735
fn c1717_l1735_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1717_l1735_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1717_l1735_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1736
fn c1718_l1736_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1718_l1736_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1718_l1736_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1737
fn c1719_l1737_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1719_l1737_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1719_l1737_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1738
fn c1720_l1738_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1720_l1738_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1720_l1738_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1739
fn c1721_l1739_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1721_l1739_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1740
fn c1722_l1740_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1722_l1740_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1741
fn c1723_l1741_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1723_l1741_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1742
fn c1724_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1724_l1742_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1743
fn c1725_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1725_l1743_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1744
fn c1726_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1726_l1744_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1745
fn c1727_l1745_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1727_l1745_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1746
fn c1728_l1746_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1728_l1746_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1747
fn c1729_l1747_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1729_l1747_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1748
fn c1730_l1748_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1730_l1748_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1749
fn c1731_l1749_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1731_l1749_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1750
fn c1732_l1750_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1732_l1750_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1751
fn c1733_l1751_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1733_l1751_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1752
fn c1734_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1734_l1752_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1753
fn c1735_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1735_l1753_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1754
fn c1736_l1754_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1736_l1754_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1755
fn c1737_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1737_l1755_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1756
fn c1738_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1738_l1756_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1757
fn c1739_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1739_l1757_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1758
fn c1740_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1740_l1758_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1759
fn c1741_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1741_l1759_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1760
fn c1742_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1742_l1760_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1761
fn c1743_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1743_l1761_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1762
fn c1744_l1762_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1744_l1762_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1763
fn c1745_l1763_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1745_l1763_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1764
fn c1746_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1746_l1764_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1765
fn c1747_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1747_l1765_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1766
fn c1748_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1748_l1766_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1767
fn c1749_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1749_l1767_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1768
fn c1750_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1750_l1768_action_invoke");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1769
fn c1751_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1751_l1769_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1770
fn c1752_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1752_l1770_action_invoke");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1771
fn c1753_l1771_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1753_l1771_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1753_l1771_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1772
fn c1754_l1772_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1754_l1772_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1754_l1772_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1773
fn c1755_l1773_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1755_l1773_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1755_l1773_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1774
fn c1756_l1774_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1756_l1774_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1756_l1774_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1775
fn c1757_l1775_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1757_l1775_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1757_l1775_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1776
fn c1758_l1776_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1758_l1776_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1758_l1776_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1777
fn c1759_l1777_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1759_l1777_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1759_l1777_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1778
fn c1760_l1778_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1760_l1778_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1760_l1778_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1779
fn c1761_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1761_l1779_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1780
fn c1762_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1762_l1780_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1781
fn c1763_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1763_l1781_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1782
fn c1764_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1764_l1782_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1783
fn c1765_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1765_l1783_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1784
fn c1766_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1766_l1784_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1785
fn c1767_l1785_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1767_l1785_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1786
fn c1768_l1786_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1768_l1786_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1787
fn c1769_l1787_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1769_l1787_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1788
fn c1770_l1788_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1770_l1788_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1789
fn c1771_l1789_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1771_l1789_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1790
fn c1772_l1790_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1772_l1790_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1791
fn c1773_l1791_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1773_l1791_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1792
fn c1774_l1792_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1774_l1792_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1793
fn c1775_l1793_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1775_l1793_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1794
fn c1776_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1776_l1794_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1795
fn c1777_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1777_l1795_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1796
fn c1778_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1778_l1796_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1797
fn c1779_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1779_l1797_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1798
fn c1780_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1780_l1798_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1799
fn c1781_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1781_l1799_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1800
fn c1782_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1782_l1800_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1801
fn c1783_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1783_l1801_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1802
fn c1784_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1784_l1802_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1803
fn c1785_l1803_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1785_l1803_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1804
fn c1786_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1786_l1804_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1805
fn c1787_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1787_l1805_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1806
fn c1788_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1788_l1806_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1807
fn c1789_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1789_l1807_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1808
fn c1790_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1790_l1808_action_invoke");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1809
fn c1791_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1791_l1809_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1810
fn c1792_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1792_l1810_action_invoke");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1811
fn c1793_l1811_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1793_l1811_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1793_l1811_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1812
fn c1794_l1812_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1794_l1812_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1794_l1812_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1813
fn c1795_l1813_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1795_l1813_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1795_l1813_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1814
fn c1796_l1814_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1796_l1814_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1796_l1814_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1815
fn c1797_l1815_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1797_l1815_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1797_l1815_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1816
fn c1798_l1816_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1798_l1816_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1798_l1816_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1817
fn c1799_l1817_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1799_l1817_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1799_l1817_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1818
fn c1800_l1818_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1800_l1818_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1800_l1818_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1819
fn c1801_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1801_l1819_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1820
fn c1802_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1802_l1820_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1821
fn c1803_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1803_l1821_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1822
fn c1804_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1804_l1822_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1823
fn c1805_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1805_l1823_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1824
fn c1806_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1806_l1824_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1825
fn c1807_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1807_l1825_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1826
fn c1808_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1808_l1826_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1827
fn c1809_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1809_l1827_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1828
fn c1810_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1810_l1828_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1829
fn c1811_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1811_l1829_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1830
fn c1812_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1812_l1830_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1831
fn c1813_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1813_l1831_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1832
fn c1814_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1814_l1832_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1833
fn c1815_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1815_l1833_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1834
fn c1816_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1816_l1834_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1835
fn c1817_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1817_l1835_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1836
fn c1818_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1818_l1836_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1837
fn c1819_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1819_l1837_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1838
fn c1820_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1820_l1838_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1839
fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1821_l1839_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1840
fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1822_l1840_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1841
fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1823_l1841_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1842
fn c1824_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1824_l1842_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1843
fn c1825_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1825_l1843_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1844
fn c1826_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1826_l1844_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1845
fn c1827_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1827_l1845_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1846
fn c1828_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1828_l1846_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1847
fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1829_l1847_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1848
fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1830_l1848_action_invoke");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1849
fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1831_l1849_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1850
fn c1832_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1832_l1850_action_invoke");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1851
fn c1833_l1851_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1833_l1851_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1833_l1851_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1852
fn c1834_l1852_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1834_l1852_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1834_l1852_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1853
fn c1835_l1853_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1835_l1853_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1835_l1853_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1854
fn c1836_l1854_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1836_l1854_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1836_l1854_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1855
fn c1837_l1855_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1837_l1855_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1837_l1855_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1856
fn c1838_l1856_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1838_l1856_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1838_l1856_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1857
fn c1839_l1857_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1839_l1857_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1839_l1857_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1858
fn c1840_l1858_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1840_l1858_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1840_l1858_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1859
fn c1841_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1841_l1859_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1860
fn c1842_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1842_l1860_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1861
fn c1843_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1843_l1861_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1862
fn c1844_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1844_l1862_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1863
fn c1845_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1845_l1863_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1864
fn c1846_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1846_l1864_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1865
fn c1847_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1847_l1865_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1866
fn c1848_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1848_l1866_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1867
fn c1849_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1849_l1867_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1868
fn c1850_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1850_l1868_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1869
fn c1851_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1851_l1869_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1870
fn c1852_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1852_l1870_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1871
fn c1853_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1853_l1871_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1872
fn c1854_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1854_l1872_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1873
fn c1855_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1855_l1873_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1874
fn c1856_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1856_l1874_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1875
fn c1857_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1857_l1875_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1876
fn c1858_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1858_l1876_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1877
fn c1859_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1859_l1877_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1878
fn c1860_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1860_l1878_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1879
fn c1861_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1861_l1879_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1880
fn c1862_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1862_l1880_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1881
fn c1863_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1863_l1881_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1882
fn c1864_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1864_l1882_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1883
fn c1865_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1865_l1883_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1884
fn c1866_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1866_l1884_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1885
fn c1867_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1867_l1885_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1886
fn c1868_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1868_l1886_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1887
fn c1869_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1869_l1887_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1888
fn c1870_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1870_l1888_action_invoke");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1889
fn c1871_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1871_l1889_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1890
fn c1872_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1872_l1890_action_invoke");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1891
fn c1873_l1891_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1873_l1891_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1873_l1891_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1892
fn c1874_l1892_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1874_l1892_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1874_l1892_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1893
fn c1875_l1893_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1875_l1893_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1875_l1893_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1894
fn c1876_l1894_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1876_l1894_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1876_l1894_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1895
fn c1877_l1895_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1877_l1895_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1877_l1895_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1896
fn c1878_l1896_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1878_l1896_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1878_l1896_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1897
fn c1879_l1897_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1879_l1897_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1879_l1897_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1898
fn c1880_l1898_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1880_l1898_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1880_l1898_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1899
fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1881_l1899_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1900
fn c1882_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1882_l1900_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1901
fn c1883_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1883_l1901_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1902
fn c1884_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1884_l1902_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1903
fn c1885_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1885_l1903_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1904
fn c1886_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1886_l1904_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1905
fn c1887_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1887_l1905_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1906
fn c1888_l1906_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1888_l1906_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 1907
fn c1889_l1907_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1889_l1907_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1908
fn c1890_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1890_l1908_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1909
fn c1891_l1909_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1891_l1909_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1910
fn c1892_l1910_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1892_l1910_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 1911
fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1893_l1911_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1912
fn c1894_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1894_l1912_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1913
fn c1895_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1895_l1913_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1914
fn c1896_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1896_l1914_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 1915
fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1897_l1915_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1916
fn c1898_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1898_l1916_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1917
fn c1899_l1917_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1899_l1917_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1918
fn c1900_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1900_l1918_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1919
fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1901_l1919_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1920
fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1902_l1920_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1921
fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1903_l1921_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1922
fn c1904_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1904_l1922_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 1923
fn c1905_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1905_l1923_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1924
fn c1906_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1906_l1924_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1925
fn c1907_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1907_l1925_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1926
fn c1908_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1908_l1926_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 1927
fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1909_l1927_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1928
fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1910_l1928_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1929
fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1911_l1929_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1930
fn c1912_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c1912_l1930_action_invoke");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 1931
fn c1913_l1931_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1913_l1931_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1913_l1931_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1932
fn c1914_l1932_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1914_l1932_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1914_l1932_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1933
fn c1915_l1933_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1915_l1933_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1915_l1933_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1934
fn c1916_l1934_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1916_l1934_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1916_l1934_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1935
fn c1917_l1935_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1917_l1935_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1917_l1935_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1936
fn c1918_l1936_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1918_l1936_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1918_l1936_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1937
fn c1919_l1937_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1919_l1937_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1919_l1937_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1938
fn c1920_l1938_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1920_l1938_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1920_l1938_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1939
fn c1921_l1939_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1921_l1939_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1921_l1939_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1940
fn c1922_l1940_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1922_l1940_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1922_l1940_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1941
fn c1923_l1941_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1923_l1941_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1923_l1941_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1942
fn c1924_l1942_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1924_l1942_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1924_l1942_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1943
fn c1925_l1943_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1925_l1943_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1925_l1943_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1944
fn c1926_l1944_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1926_l1944_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1926_l1944_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1945
fn c1927_l1945_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1927_l1945_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1927_l1945_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1946
fn c1928_l1946_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1928_l1946_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1928_l1946_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1947
fn c1929_l1947_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1929_l1947_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1929_l1947_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1948
fn c1930_l1948_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1930_l1948_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1930_l1948_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1949
fn c1931_l1949_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1931_l1949_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1931_l1949_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1950
fn c1932_l1950_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1932_l1950_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1932_l1950_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1951
fn c1933_l1951_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1933_l1951_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1933_l1951_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1952
fn c1934_l1952_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1934_l1952_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1934_l1952_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1953
fn c1935_l1953_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1935_l1953_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1935_l1953_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1954
fn c1936_l1954_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1936_l1954_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1936_l1954_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1955
fn c1937_l1955_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1937_l1955_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1937_l1955_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1956
fn c1938_l1956_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1938_l1956_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1938_l1956_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1957
fn c1939_l1957_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1939_l1957_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1939_l1957_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1958
fn c1940_l1958_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1940_l1958_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1940_l1958_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1959
fn c1941_l1959_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1941_l1959_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1941_l1959_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1960
fn c1942_l1960_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1942_l1960_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1942_l1960_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1961
fn c1943_l1961_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1943_l1961_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1943_l1961_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1962
fn c1944_l1962_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1944_l1962_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1944_l1962_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1963
fn c1945_l1963_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1945_l1963_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1945_l1963_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1964
fn c1946_l1964_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1946_l1964_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1946_l1964_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1965
fn c1947_l1965_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1947_l1965_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1947_l1965_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1966
fn c1948_l1966_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1948_l1966_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1948_l1966_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1967
fn c1949_l1967_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1949_l1967_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1949_l1967_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1968
fn c1950_l1968_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1950_l1968_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1950_l1968_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1969
fn c1951_l1969_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1951_l1969_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1951_l1969_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1970
fn c1952_l1970_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1952_l1970_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1952_l1970_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1971
fn c1953_l1971_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1953_l1971_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1953_l1971_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1972
fn c1954_l1972_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1954_l1972_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1954_l1972_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1973
fn c1955_l1973_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1955_l1973_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1955_l1973_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1974
fn c1956_l1974_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1956_l1974_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1956_l1974_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1975
fn c1957_l1975_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1957_l1975_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1957_l1975_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1976
fn c1958_l1976_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1958_l1976_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1958_l1976_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1977
fn c1959_l1977_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1959_l1977_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1959_l1977_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1978
fn c1960_l1978_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1960_l1978_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1960_l1978_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1979
fn c1961_l1979_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1961_l1979_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1961_l1979_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1980
fn c1962_l1980_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1962_l1980_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1962_l1980_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1981
fn c1963_l1981_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1963_l1981_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1963_l1981_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1982
fn c1964_l1982_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1964_l1982_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1964_l1982_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1983
fn c1965_l1983_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1965_l1983_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1965_l1983_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1984
fn c1966_l1984_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1966_l1984_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1966_l1984_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1985
fn c1967_l1985_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1967_l1985_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1967_l1985_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1986
fn c1968_l1986_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1968_l1986_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1968_l1986_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1987
fn c1969_l1987_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1969_l1987_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1969_l1987_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1988
fn c1970_l1988_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1970_l1988_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1970_l1988_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1989
fn c1971_l1989_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1971_l1989_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1971_l1989_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1990
fn c1972_l1990_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1972_l1990_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1972_l1990_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1991
fn c1973_l1991_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1973_l1991_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1973_l1991_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1992
fn c1974_l1992_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1974_l1992_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1974_l1992_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1993
fn c1975_l1993_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1975_l1993_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1975_l1993_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1994
fn c1976_l1994_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1976_l1994_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1976_l1994_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1995
fn c1977_l1995_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1977_l1995_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1977_l1995_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1996
fn c1978_l1996_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1978_l1996_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1978_l1996_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1997
fn c1979_l1997_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1979_l1997_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1979_l1997_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1998
fn c1980_l1998_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1980_l1998_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1980_l1998_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 1999
fn c1981_l1999_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1981_l1999_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1981_l1999_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2000
fn c1982_l2000_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1982_l2000_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1982_l2000_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2001
fn c1983_l2001_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1983_l2001_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1983_l2001_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2002
fn c1984_l2002_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1984_l2002_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1984_l2002_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2003
fn c1985_l2003_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1985_l2003_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1985_l2003_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2004
fn c1986_l2004_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1986_l2004_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1986_l2004_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2005
fn c1987_l2005_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1987_l2005_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1987_l2005_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2006
fn c1988_l2006_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1988_l2006_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1988_l2006_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2007
fn c1989_l2007_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1989_l2007_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1989_l2007_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2008
fn c1990_l2008_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1990_l2008_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1990_l2008_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2009
fn c1991_l2009_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1991_l2009_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1991_l2009_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2010
fn c1992_l2010_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1992_l2010_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1992_l2010_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2011
fn c1993_l2011_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1993_l2011_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1993_l2011_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2012
fn c1994_l2012_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1994_l2012_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1994_l2012_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2013
fn c1995_l2013_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1995_l2013_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1995_l2013_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2014
fn c1996_l2014_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1996_l2014_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1996_l2014_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2015
fn c1997_l2015_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1997_l2015_assert_return_canonical_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1997_l2015_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2016
fn c1998_l2016_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1998_l2016_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1998_l2016_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2017
fn c1999_l2017_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c1999_l2017_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1999_l2017_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2018
fn c2000_l2018_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2000_l2018_assert_return_arithmetic_nan");
    let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2000_l2018_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2019
fn c2001_l2019_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2001_l2019_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2020
fn c2002_l2020_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2002_l2020_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2021
fn c2003_l2021_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2003_l2021_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2022
fn c2004_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2004_l2022_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2023
fn c2005_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2005_l2023_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2024
fn c2006_l2024_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2006_l2024_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2025
fn c2007_l2025_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2007_l2025_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2026
fn c2008_l2026_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2008_l2026_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2027
fn c2009_l2027_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2009_l2027_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2028
fn c2010_l2028_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2010_l2028_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2029
fn c2011_l2029_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2011_l2029_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2030
fn c2012_l2030_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2012_l2030_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2031
fn c2013_l2031_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2013_l2031_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2032
fn c2014_l2032_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2014_l2032_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2033
fn c2015_l2033_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2015_l2033_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2034
fn c2016_l2034_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2016_l2034_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2035
fn c2017_l2035_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2017_l2035_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2036
fn c2018_l2036_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2018_l2036_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2037
fn c2019_l2037_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2019_l2037_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2038
fn c2020_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2020_l2038_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2039
fn c2021_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2021_l2039_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2040
fn c2022_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2022_l2040_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2041
fn c2023_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2023_l2041_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2042
fn c2024_l2042_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2024_l2042_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2043
fn c2025_l2043_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2025_l2043_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2044
fn c2026_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2026_l2044_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2045
fn c2027_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2027_l2045_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2046
fn c2028_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2028_l2046_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2047
fn c2029_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2029_l2047_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2048
fn c2030_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2030_l2048_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2049
fn c2031_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2031_l2049_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2050
fn c2032_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2032_l2050_action_invoke");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2051
fn c2033_l2051_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2033_l2051_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2033_l2051_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2052
fn c2034_l2052_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2034_l2052_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2034_l2052_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2053
fn c2035_l2053_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2035_l2053_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2035_l2053_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2054
fn c2036_l2054_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2036_l2054_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2036_l2054_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2055
fn c2037_l2055_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2037_l2055_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2037_l2055_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2056
fn c2038_l2056_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2038_l2056_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2038_l2056_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2057
fn c2039_l2057_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2039_l2057_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2039_l2057_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2058
fn c2040_l2058_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2040_l2058_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2040_l2058_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2059
fn c2041_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2041_l2059_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2060
fn c2042_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2042_l2060_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2061
fn c2043_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2043_l2061_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2062
fn c2044_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2044_l2062_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2063
fn c2045_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2045_l2063_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2064
fn c2046_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2046_l2064_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2065
fn c2047_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2047_l2065_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2066
fn c2048_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2048_l2066_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2067
fn c2049_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2049_l2067_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2068
fn c2050_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2050_l2068_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2069
fn c2051_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2051_l2069_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2070
fn c2052_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2052_l2070_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2071
fn c2053_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2053_l2071_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2072
fn c2054_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2054_l2072_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2073
fn c2055_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2055_l2073_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2074
fn c2056_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2056_l2074_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2075
fn c2057_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2057_l2075_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2076
fn c2058_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2058_l2076_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2077
fn c2059_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2059_l2077_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2078
fn c2060_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2060_l2078_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2079
fn c2061_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2061_l2079_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2080
fn c2062_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2062_l2080_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2081
fn c2063_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2063_l2081_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2082
fn c2064_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2064_l2082_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2083
fn c2065_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2065_l2083_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2084
fn c2066_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2066_l2084_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2085
fn c2067_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2067_l2085_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2086
fn c2068_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2068_l2086_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2087
fn c2069_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2069_l2087_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2088
fn c2070_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2070_l2088_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2089
fn c2071_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2071_l2089_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2090
fn c2072_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2072_l2090_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2091
fn c2073_l2091_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2073_l2091_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2073_l2091_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2092
fn c2074_l2092_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2074_l2092_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2074_l2092_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2093
fn c2075_l2093_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2075_l2093_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2075_l2093_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2094
fn c2076_l2094_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2076_l2094_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2076_l2094_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2095
fn c2077_l2095_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2077_l2095_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2077_l2095_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2096
fn c2078_l2096_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2078_l2096_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2078_l2096_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2097
fn c2079_l2097_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2079_l2097_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2079_l2097_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2098
fn c2080_l2098_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2080_l2098_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2080_l2098_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2099
fn c2081_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2081_l2099_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2100
fn c2082_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2082_l2100_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2101
fn c2083_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2083_l2101_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2102
fn c2084_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2084_l2102_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2103
fn c2085_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2085_l2103_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2104
fn c2086_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2086_l2104_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2105
fn c2087_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2087_l2105_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2106
fn c2088_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2088_l2106_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2107
fn c2089_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2089_l2107_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2108
fn c2090_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2090_l2108_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2109
fn c2091_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2091_l2109_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2110
fn c2092_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2092_l2110_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2111
fn c2093_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2093_l2111_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2112
fn c2094_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2094_l2112_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2113
fn c2095_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2095_l2113_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2114
fn c2096_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2096_l2114_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2115
fn c2097_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2097_l2115_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2116
fn c2098_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2098_l2116_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2117
fn c2099_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2099_l2117_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2118
fn c2100_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2100_l2118_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2119
fn c2101_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2101_l2119_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2120
fn c2102_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2102_l2120_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2121
fn c2103_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2103_l2121_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2122
fn c2104_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2104_l2122_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2123
fn c2105_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2105_l2123_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2124
fn c2106_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2106_l2124_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2125
fn c2107_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2107_l2125_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2126
fn c2108_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2108_l2126_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2127
fn c2109_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2109_l2127_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2128
fn c2110_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2110_l2128_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2129
fn c2111_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2111_l2129_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2130
fn c2112_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2112_l2130_action_invoke");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2131
fn c2113_l2131_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2113_l2131_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2113_l2131_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2132
fn c2114_l2132_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2114_l2132_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2114_l2132_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2133
fn c2115_l2133_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2115_l2133_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2115_l2133_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2134
fn c2116_l2134_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2116_l2134_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2116_l2134_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2135
fn c2117_l2135_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2117_l2135_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2117_l2135_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2136
fn c2118_l2136_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2118_l2136_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2118_l2136_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2137
fn c2119_l2137_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2119_l2137_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2119_l2137_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2138
fn c2120_l2138_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2120_l2138_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2120_l2138_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2139
fn c2121_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2121_l2139_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2140
fn c2122_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2122_l2140_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2141
fn c2123_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2123_l2141_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2142
fn c2124_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2124_l2142_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2143
fn c2125_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2125_l2143_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2144
fn c2126_l2144_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2126_l2144_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2145
fn c2127_l2145_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2127_l2145_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2146
fn c2128_l2146_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2128_l2146_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2147
fn c2129_l2147_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2129_l2147_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2148
fn c2130_l2148_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2130_l2148_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2149
fn c2131_l2149_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2131_l2149_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2150
fn c2132_l2150_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2132_l2150_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2151
fn c2133_l2151_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2133_l2151_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2152
fn c2134_l2152_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2134_l2152_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2153
fn c2135_l2153_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2135_l2153_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2154
fn c2136_l2154_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2136_l2154_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2155
fn c2137_l2155_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2137_l2155_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2156
fn c2138_l2156_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2138_l2156_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2157
fn c2139_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2139_l2157_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2158
fn c2140_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2140_l2158_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2159
fn c2141_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2141_l2159_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2160
fn c2142_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2142_l2160_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2161
fn c2143_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2143_l2161_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2162
fn c2144_l2162_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2144_l2162_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2163
fn c2145_l2163_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2145_l2163_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2164
fn c2146_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2146_l2164_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2165
fn c2147_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2147_l2165_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2166
fn c2148_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2148_l2166_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2167
fn c2149_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2149_l2167_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2168
fn c2150_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2150_l2168_action_invoke");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2169
fn c2151_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2151_l2169_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2170
fn c2152_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2152_l2170_action_invoke");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2171
fn c2153_l2171_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2153_l2171_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2153_l2171_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2172
fn c2154_l2172_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2154_l2172_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2154_l2172_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2173
fn c2155_l2173_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2155_l2173_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2155_l2173_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2174
fn c2156_l2174_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2156_l2174_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2156_l2174_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2175
fn c2157_l2175_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2157_l2175_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2157_l2175_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2176
fn c2158_l2176_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2158_l2176_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2158_l2176_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2177
fn c2159_l2177_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2159_l2177_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2159_l2177_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2178
fn c2160_l2178_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2160_l2178_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2160_l2178_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2179
fn c2161_l2179_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2161_l2179_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2180
fn c2162_l2180_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2162_l2180_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2181
fn c2163_l2181_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2163_l2181_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2182
fn c2164_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2164_l2182_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2183
fn c2165_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2165_l2183_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2184
fn c2166_l2184_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2166_l2184_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2185
fn c2167_l2185_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2167_l2185_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2186
fn c2168_l2186_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2168_l2186_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2187
fn c2169_l2187_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2169_l2187_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2188
fn c2170_l2188_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2170_l2188_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2189
fn c2171_l2189_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2171_l2189_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2190
fn c2172_l2190_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2172_l2190_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2191
fn c2173_l2191_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2173_l2191_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2192
fn c2174_l2192_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2174_l2192_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2193
fn c2175_l2193_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2175_l2193_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2194
fn c2176_l2194_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2176_l2194_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2195
fn c2177_l2195_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2177_l2195_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2196
fn c2178_l2196_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2178_l2196_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2197
fn c2179_l2197_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2179_l2197_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2198
fn c2180_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2180_l2198_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2199
fn c2181_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2181_l2199_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2200
fn c2182_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2182_l2200_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2201
fn c2183_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2183_l2201_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2202
fn c2184_l2202_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2184_l2202_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2203
fn c2185_l2203_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2185_l2203_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2204
fn c2186_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2186_l2204_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2205
fn c2187_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2187_l2205_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2206
fn c2188_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2188_l2206_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2207
fn c2189_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2189_l2207_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2208
fn c2190_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2190_l2208_action_invoke");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2209
fn c2191_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2191_l2209_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2210
fn c2192_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2192_l2210_action_invoke");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2211
fn c2193_l2211_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2193_l2211_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2193_l2211_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2212
fn c2194_l2212_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2194_l2212_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2194_l2212_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2213
fn c2195_l2213_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2195_l2213_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2195_l2213_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2214
fn c2196_l2214_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2196_l2214_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2196_l2214_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2215
fn c2197_l2215_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2197_l2215_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2197_l2215_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2216
fn c2198_l2216_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2198_l2216_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2198_l2216_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2217
fn c2199_l2217_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2199_l2217_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2199_l2217_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2218
fn c2200_l2218_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2200_l2218_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2200_l2218_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2219
fn c2201_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2201_l2219_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2220
fn c2202_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2202_l2220_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2221
fn c2203_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2203_l2221_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2222
fn c2204_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2204_l2222_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2223
fn c2205_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2205_l2223_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2224
fn c2206_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2206_l2224_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2225
fn c2207_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2207_l2225_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2226
fn c2208_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2208_l2226_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2227
fn c2209_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2209_l2227_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2228
fn c2210_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2210_l2228_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2229
fn c2211_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2211_l2229_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2230
fn c2212_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2212_l2230_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2231
fn c2213_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2213_l2231_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2232
fn c2214_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2214_l2232_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2233
fn c2215_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2215_l2233_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2234
fn c2216_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2216_l2234_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2235
fn c2217_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2217_l2235_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2236
fn c2218_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2218_l2236_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2237
fn c2219_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2219_l2237_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2238
fn c2220_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2220_l2238_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2239
fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2221_l2239_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2240
fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2222_l2240_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2241
fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2223_l2241_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2242
fn c2224_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2224_l2242_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2243
fn c2225_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2225_l2243_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2244
fn c2226_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2226_l2244_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2245
fn c2227_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2227_l2245_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2246
fn c2228_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2228_l2246_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2247
fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2229_l2247_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2248
fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2230_l2248_action_invoke");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2249
fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2231_l2249_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2250
fn c2232_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2232_l2250_action_invoke");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2251
fn c2233_l2251_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2233_l2251_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2233_l2251_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2252
fn c2234_l2252_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2234_l2252_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2234_l2252_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2253
fn c2235_l2253_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2235_l2253_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2235_l2253_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2254
fn c2236_l2254_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2236_l2254_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2236_l2254_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2255
fn c2237_l2255_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2237_l2255_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2237_l2255_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2256
fn c2238_l2256_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2238_l2256_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2238_l2256_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2257
fn c2239_l2257_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2239_l2257_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2239_l2257_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2258
fn c2240_l2258_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2240_l2258_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2240_l2258_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2259
fn c2241_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2241_l2259_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2260
fn c2242_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2242_l2260_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2261
fn c2243_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2243_l2261_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2262
fn c2244_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2244_l2262_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2263
fn c2245_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2245_l2263_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2264
fn c2246_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2246_l2264_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2265
fn c2247_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2247_l2265_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2266
fn c2248_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2248_l2266_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2267
fn c2249_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2249_l2267_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2268
fn c2250_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2250_l2268_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2269
fn c2251_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2251_l2269_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2270
fn c2252_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2252_l2270_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2271
fn c2253_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2253_l2271_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2272
fn c2254_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2254_l2272_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2273
fn c2255_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2255_l2273_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2274
fn c2256_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2256_l2274_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2275
fn c2257_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2257_l2275_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2276
fn c2258_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2258_l2276_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2277
fn c2259_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2259_l2277_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2278
fn c2260_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2260_l2278_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2279
fn c2261_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2261_l2279_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2280
fn c2262_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2262_l2280_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2281
fn c2263_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2263_l2281_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2282
fn c2264_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2264_l2282_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2283
fn c2265_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2265_l2283_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2284
fn c2266_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2266_l2284_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2285
fn c2267_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2267_l2285_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2286
fn c2268_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2268_l2286_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2287
fn c2269_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2269_l2287_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2288
fn c2270_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2270_l2288_action_invoke");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2289
fn c2271_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2271_l2289_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2290
fn c2272_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2272_l2290_action_invoke");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2291
fn c2273_l2291_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2273_l2291_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2273_l2291_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2292
fn c2274_l2292_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2274_l2292_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2274_l2292_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2293
fn c2275_l2293_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2275_l2293_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2275_l2293_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2294
fn c2276_l2294_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2276_l2294_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2276_l2294_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2295
fn c2277_l2295_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2277_l2295_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2277_l2295_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2296
fn c2278_l2296_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2278_l2296_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2278_l2296_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2297
fn c2279_l2297_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2279_l2297_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2279_l2297_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2298
fn c2280_l2298_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2280_l2298_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2280_l2298_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2299
fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2281_l2299_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2300
fn c2282_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2282_l2300_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2301
fn c2283_l2301_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2283_l2301_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2302
fn c2284_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2284_l2302_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2303
fn c2285_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2285_l2303_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2304
fn c2286_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2286_l2304_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
    result.map(|_| ())
}

// Line 2305
fn c2287_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2287_l2305_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2306
fn c2288_l2306_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2288_l2306_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2307
fn c2289_l2307_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2289_l2307_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2308
fn c2290_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2290_l2308_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
    result.map(|_| ())
}

// Line 2309
fn c2291_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2291_l2309_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2310
fn c2292_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2292_l2310_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2311
fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2293_l2311_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2312
fn c2294_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2294_l2312_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
    result.map(|_| ())
}

// Line 2313
fn c2295_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2295_l2313_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2314
fn c2296_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2296_l2314_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2315
fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2297_l2315_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2316
fn c2298_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2298_l2316_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2317
fn c2299_l2317_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2299_l2317_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2318
fn c2300_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2300_l2318_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2319
fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2301_l2319_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2320
fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2302_l2320_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
    result.map(|_| ())
}

// Line 2321
fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2303_l2321_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2322
fn c2304_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2304_l2322_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2323
fn c2305_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2305_l2323_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2324
fn c2306_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2306_l2324_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2325
fn c2307_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2307_l2325_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2326
fn c2308_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2308_l2326_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2327
fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2309_l2327_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2328
fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2310_l2328_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2329
fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2311_l2329_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2330
fn c2312_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2312_l2330_action_invoke");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2331
fn c2313_l2331_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2313_l2331_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2313_l2331_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2332
fn c2314_l2332_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2314_l2332_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2314_l2332_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2333
fn c2315_l2333_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2315_l2333_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2315_l2333_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2334
fn c2316_l2334_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2316_l2334_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2316_l2334_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2335
fn c2317_l2335_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2317_l2335_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2317_l2335_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2336
fn c2318_l2336_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2318_l2336_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2318_l2336_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2337
fn c2319_l2337_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2319_l2337_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2319_l2337_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2338
fn c2320_l2338_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2320_l2338_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2320_l2338_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2339
fn c2321_l2339_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2321_l2339_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c2321_l2339_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2340
fn c2322_l2340_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2322_l2340_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c2322_l2340_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2341
fn c2323_l2341_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2323_l2341_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c2323_l2341_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2342
fn c2324_l2342_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2324_l2342_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c2324_l2342_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2343
fn c2325_l2343_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2325_l2343_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c2325_l2343_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2344
fn c2326_l2344_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2326_l2344_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c2326_l2344_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2345
fn c2327_l2345_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2327_l2345_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c2327_l2345_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2346
fn c2328_l2346_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2328_l2346_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c2328_l2346_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2347
fn c2329_l2347_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2329_l2347_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2329_l2347_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2348
fn c2330_l2348_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2330_l2348_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2330_l2348_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2349
fn c2331_l2349_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2331_l2349_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2331_l2349_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2350
fn c2332_l2350_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2332_l2350_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2332_l2350_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2351
fn c2333_l2351_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2333_l2351_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2333_l2351_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2352
fn c2334_l2352_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2334_l2352_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2334_l2352_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2353
fn c2335_l2353_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2335_l2353_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2335_l2353_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2354
fn c2336_l2354_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2336_l2354_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2336_l2354_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2355
fn c2337_l2355_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2337_l2355_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2337_l2355_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2356
fn c2338_l2356_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2338_l2356_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2338_l2356_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2357
fn c2339_l2357_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2339_l2357_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2339_l2357_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2358
fn c2340_l2358_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2340_l2358_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2340_l2358_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2359
fn c2341_l2359_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2341_l2359_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2341_l2359_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2360
fn c2342_l2360_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2342_l2360_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2342_l2360_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2361
fn c2343_l2361_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2343_l2361_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2343_l2361_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2362
fn c2344_l2362_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2344_l2362_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2344_l2362_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2363
fn c2345_l2363_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2345_l2363_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2345_l2363_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2364
fn c2346_l2364_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2346_l2364_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2346_l2364_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2365
fn c2347_l2365_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2347_l2365_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c2347_l2365_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2366
fn c2348_l2366_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2348_l2366_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c2348_l2366_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2367
fn c2349_l2367_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2349_l2367_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2349_l2367_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2368
fn c2350_l2368_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2350_l2368_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2350_l2368_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2369
fn c2351_l2369_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2351_l2369_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c2351_l2369_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2370
fn c2352_l2370_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2352_l2370_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c2352_l2370_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2371
fn c2353_l2371_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2353_l2371_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2353_l2371_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2372
fn c2354_l2372_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2354_l2372_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2354_l2372_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2373
fn c2355_l2373_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2355_l2373_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c2355_l2373_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2374
fn c2356_l2374_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2356_l2374_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c2356_l2374_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2375
fn c2357_l2375_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2357_l2375_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2357_l2375_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2376
fn c2358_l2376_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2358_l2376_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2358_l2376_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2377
fn c2359_l2377_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2359_l2377_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c2359_l2377_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2378
fn c2360_l2378_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2360_l2378_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c2360_l2378_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2379
fn c2361_l2379_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2361_l2379_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2361_l2379_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2380
fn c2362_l2380_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2362_l2380_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2362_l2380_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2381
fn c2363_l2381_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2363_l2381_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2363_l2381_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2382
fn c2364_l2382_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2364_l2382_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2364_l2382_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2383
fn c2365_l2383_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2365_l2383_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2365_l2383_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2384
fn c2366_l2384_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2366_l2384_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2366_l2384_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2385
fn c2367_l2385_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2367_l2385_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2367_l2385_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2386
fn c2368_l2386_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2368_l2386_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2368_l2386_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2387
fn c2369_l2387_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2369_l2387_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2369_l2387_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2388
fn c2370_l2388_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2370_l2388_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2370_l2388_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2389
fn c2371_l2389_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2371_l2389_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2371_l2389_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2390
fn c2372_l2390_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2372_l2390_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2372_l2390_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2391
fn c2373_l2391_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2373_l2391_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2373_l2391_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2392
fn c2374_l2392_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2374_l2392_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2374_l2392_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2393
fn c2375_l2393_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2375_l2393_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2375_l2393_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2394
fn c2376_l2394_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2376_l2394_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2376_l2394_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2395
fn c2377_l2395_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2377_l2395_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2377_l2395_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2396
fn c2378_l2396_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2378_l2396_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2378_l2396_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2397
fn c2379_l2397_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2379_l2397_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c2379_l2397_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2398
fn c2380_l2398_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2380_l2398_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c2380_l2398_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2399
fn c2381_l2399_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2381_l2399_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2381_l2399_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2400
fn c2382_l2400_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2382_l2400_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2382_l2400_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2401
fn c2383_l2401_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2383_l2401_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c2383_l2401_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2402
fn c2384_l2402_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2384_l2402_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c2384_l2402_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2403
fn c2385_l2403_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2385_l2403_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2385_l2403_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2404
fn c2386_l2404_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2386_l2404_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2386_l2404_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2405
fn c2387_l2405_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2387_l2405_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2387_l2405_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2406
fn c2388_l2406_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2388_l2406_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2388_l2406_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2407
fn c2389_l2407_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2389_l2407_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2389_l2407_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2408
fn c2390_l2408_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2390_l2408_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2390_l2408_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2409
fn c2391_l2409_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2391_l2409_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2391_l2409_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2410
fn c2392_l2410_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2392_l2410_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2392_l2410_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2411
fn c2393_l2411_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2393_l2411_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2393_l2411_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2412
fn c2394_l2412_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2394_l2412_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2394_l2412_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2413
fn c2395_l2413_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2395_l2413_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2395_l2413_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2414
fn c2396_l2414_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2396_l2414_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2396_l2414_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2415
fn c2397_l2415_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2397_l2415_assert_return_canonical_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2397_l2415_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2416
fn c2398_l2416_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2398_l2416_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2398_l2416_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2417
fn c2399_l2417_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2399_l2417_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2399_l2417_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2418
fn c2400_l2418_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2400_l2418_assert_return_arithmetic_nan");
    let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2400_l2418_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2419
fn c2401_l2419_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2401_l2419_action_invoke");
    let result = instance.call("sqrt", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2420
fn c2402_l2420_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2402_l2420_action_invoke");
    let result = instance.call("sqrt", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2421
fn c2403_l2421_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2403_l2421_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2403_l2421_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2422
fn c2404_l2422_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2404_l2422_action_invoke");
    let result = instance.call("sqrt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000003743392f32).to_bits()))));
    result.map(|_| ())
}

// Line 2423
fn c2405_l2423_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2405_l2423_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2405_l2423_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2424
fn c2406_l2424_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2406_l2424_action_invoke");
    let result = instance.call("sqrt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000010842022f32).to_bits()))));
    result.map(|_| ())
}

// Line 2425
fn c2407_l2425_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2407_l2425_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2407_l2425_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2426
fn c2408_l2426_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2408_l2426_action_invoke");
    let result = instance.call("sqrt", &[Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.70710677f32).to_bits()))));
    result.map(|_| ())
}

// Line 2427
fn c2409_l2427_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2409_l2427_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2409_l2427_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2428
fn c2410_l2428_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2410_l2428_action_invoke");
    let result = instance.call("sqrt", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2429
fn c2411_l2429_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2411_l2429_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2411_l2429_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2430
fn c2412_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2412_l2430_action_invoke");
    let result = instance.call("sqrt", &[Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((2.5066283f32).to_bits()))));
    result.map(|_| ())
}

// Line 2431
fn c2413_l2431_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2413_l2431_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2413_l2431_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2432
fn c2414_l2432_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2414_l2432_action_invoke");
    let result = instance.call("sqrt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((18446743000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2433
fn c2415_l2433_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2415_l2433_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2415_l2433_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2434
fn c2416_l2434_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2416_l2434_action_invoke");
    let result = instance.call("sqrt", &[Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2435
fn c2417_l2435_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2417_l2435_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2417_l2435_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2436
fn c2418_l2436_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2418_l2436_assert_return_arithmetic_nan");
    let result = instance.call("sqrt", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2418_l2436_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2437
fn c2419_l2437_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2419_l2437_assert_return_canonical_nan");
    let result = instance.call("sqrt", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2419_l2437_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2438
fn c2420_l2438_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2420_l2438_assert_return_arithmetic_nan");
    let result = instance.call("sqrt", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2420_l2438_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2439
fn c2421_l2439_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2421_l2439_action_invoke");
    let result = instance.call("floor", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2440
fn c2422_l2440_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2422_l2440_action_invoke");
    let result = instance.call("floor", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2441
fn c2423_l2441_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2423_l2441_action_invoke");
    let result = instance.call("floor", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2442
fn c2424_l2442_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2424_l2442_action_invoke");
    let result = instance.call("floor", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2443
fn c2425_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2425_l2443_action_invoke");
    let result = instance.call("floor", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2444
fn c2426_l2444_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2426_l2444_action_invoke");
    let result = instance.call("floor", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2445
fn c2427_l2445_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2427_l2445_action_invoke");
    let result = instance.call("floor", &[Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2446
fn c2428_l2446_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2428_l2446_action_invoke");
    let result = instance.call("floor", &[Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2447
fn c2429_l2447_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2429_l2447_action_invoke");
    let result = instance.call("floor", &[Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2448
fn c2430_l2448_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2430_l2448_action_invoke");
    let result = instance.call("floor", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2449
fn c2431_l2449_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2431_l2449_action_invoke");
    let result = instance.call("floor", &[Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-7.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2450
fn c2432_l2450_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2432_l2450_action_invoke");
    let result = instance.call("floor", &[Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2451
fn c2433_l2451_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2433_l2451_action_invoke");
    let result = instance.call("floor", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2452
fn c2434_l2452_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2434_l2452_action_invoke");
    let result = instance.call("floor", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2453
fn c2435_l2453_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2435_l2453_action_invoke");
    let result = instance.call("floor", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2454
fn c2436_l2454_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2436_l2454_action_invoke");
    let result = instance.call("floor", &[Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2455
fn c2437_l2455_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2437_l2455_assert_return_canonical_nan");
    let result = instance.call("floor", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2437_l2455_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2456
fn c2438_l2456_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2438_l2456_assert_return_arithmetic_nan");
    let result = instance.call("floor", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2438_l2456_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2457
fn c2439_l2457_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2439_l2457_assert_return_canonical_nan");
    let result = instance.call("floor", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2439_l2457_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2458
fn c2440_l2458_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2440_l2458_assert_return_arithmetic_nan");
    let result = instance.call("floor", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2440_l2458_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2459
fn c2441_l2459_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2441_l2459_action_invoke");
    let result = instance.call("ceil", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2460
fn c2442_l2460_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2442_l2460_action_invoke");
    let result = instance.call("ceil", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2461
fn c2443_l2461_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2443_l2461_action_invoke");
    let result = instance.call("ceil", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2462
fn c2444_l2462_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2444_l2462_action_invoke");
    let result = instance.call("ceil", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2463
fn c2445_l2463_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2445_l2463_action_invoke");
    let result = instance.call("ceil", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2464
fn c2446_l2464_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2446_l2464_action_invoke");
    let result = instance.call("ceil", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2465
fn c2447_l2465_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2447_l2465_action_invoke");
    let result = instance.call("ceil", &[Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2466
fn c2448_l2466_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2448_l2466_action_invoke");
    let result = instance.call("ceil", &[Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2467
fn c2449_l2467_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2449_l2467_action_invoke");
    let result = instance.call("ceil", &[Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2468
fn c2450_l2468_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2450_l2468_action_invoke");
    let result = instance.call("ceil", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2469
fn c2451_l2469_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2451_l2469_action_invoke");
    let result = instance.call("ceil", &[Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2470
fn c2452_l2470_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2452_l2470_action_invoke");
    let result = instance.call("ceil", &[Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((7.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2471
fn c2453_l2471_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2453_l2471_action_invoke");
    let result = instance.call("ceil", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2472
fn c2454_l2472_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2454_l2472_action_invoke");
    let result = instance.call("ceil", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2473
fn c2455_l2473_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2455_l2473_action_invoke");
    let result = instance.call("ceil", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2474
fn c2456_l2474_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2456_l2474_action_invoke");
    let result = instance.call("ceil", &[Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2475
fn c2457_l2475_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2457_l2475_assert_return_canonical_nan");
    let result = instance.call("ceil", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2457_l2475_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2476
fn c2458_l2476_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2458_l2476_assert_return_arithmetic_nan");
    let result = instance.call("ceil", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2458_l2476_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2477
fn c2459_l2477_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2459_l2477_assert_return_canonical_nan");
    let result = instance.call("ceil", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2459_l2477_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2478
fn c2460_l2478_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2460_l2478_assert_return_arithmetic_nan");
    let result = instance.call("ceil", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2460_l2478_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2479
fn c2461_l2479_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2461_l2479_action_invoke");
    let result = instance.call("trunc", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2480
fn c2462_l2480_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2462_l2480_action_invoke");
    let result = instance.call("trunc", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2481
fn c2463_l2481_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2463_l2481_action_invoke");
    let result = instance.call("trunc", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2482
fn c2464_l2482_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2464_l2482_action_invoke");
    let result = instance.call("trunc", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2483
fn c2465_l2483_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2465_l2483_action_invoke");
    let result = instance.call("trunc", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2484
fn c2466_l2484_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2466_l2484_action_invoke");
    let result = instance.call("trunc", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2485
fn c2467_l2485_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2467_l2485_action_invoke");
    let result = instance.call("trunc", &[Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2486
fn c2468_l2486_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2468_l2486_action_invoke");
    let result = instance.call("trunc", &[Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2487
fn c2469_l2487_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2469_l2487_action_invoke");
    let result = instance.call("trunc", &[Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2488
fn c2470_l2488_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2470_l2488_action_invoke");
    let result = instance.call("trunc", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2489
fn c2471_l2489_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2471_l2489_action_invoke");
    let result = instance.call("trunc", &[Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2490
fn c2472_l2490_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2472_l2490_action_invoke");
    let result = instance.call("trunc", &[Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2491
fn c2473_l2491_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2473_l2491_action_invoke");
    let result = instance.call("trunc", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2492
fn c2474_l2492_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2474_l2492_action_invoke");
    let result = instance.call("trunc", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2493
fn c2475_l2493_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2475_l2493_action_invoke");
    let result = instance.call("trunc", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2494
fn c2476_l2494_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2476_l2494_action_invoke");
    let result = instance.call("trunc", &[Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2495
fn c2477_l2495_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2477_l2495_assert_return_canonical_nan");
    let result = instance.call("trunc", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2477_l2495_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2496
fn c2478_l2496_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2478_l2496_assert_return_arithmetic_nan");
    let result = instance.call("trunc", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2478_l2496_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2497
fn c2479_l2497_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2479_l2497_assert_return_canonical_nan");
    let result = instance.call("trunc", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2479_l2497_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2498
fn c2480_l2498_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2480_l2498_assert_return_arithmetic_nan");
    let result = instance.call("trunc", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2480_l2498_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2499
fn c2481_l2499_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2481_l2499_action_invoke");
    let result = instance.call("nearest", &[Value::F32((-0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2500
fn c2482_l2500_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2482_l2500_action_invoke");
    let result = instance.call("nearest", &[Value::F32((0.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2501
fn c2483_l2501_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2483_l2501_action_invoke");
    let result = instance.call("nearest", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2502
fn c2484_l2502_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2484_l2502_action_invoke");
    let result = instance.call("nearest", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2503
fn c2485_l2503_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2485_l2503_action_invoke");
    let result = instance.call("nearest", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2504
fn c2486_l2504_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2486_l2504_action_invoke");
    let result = instance.call("nearest", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2505
fn c2487_l2505_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2487_l2505_action_invoke");
    let result = instance.call("nearest", &[Value::F32((-0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2506
fn c2488_l2506_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2488_l2506_action_invoke");
    let result = instance.call("nearest", &[Value::F32((0.5f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2507
fn c2489_l2507_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2489_l2507_action_invoke");
    let result = instance.call("nearest", &[Value::F32((-1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2508
fn c2490_l2508_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2490_l2508_action_invoke");
    let result = instance.call("nearest", &[Value::F32((1.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2509
fn c2491_l2509_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2491_l2509_action_invoke");
    let result = instance.call("nearest", &[Value::F32((-6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-6.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2510
fn c2492_l2510_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2492_l2510_action_invoke");
    let result = instance.call("nearest", &[Value::F32((6.2831855f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2511
fn c2493_l2511_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2493_l2511_action_invoke");
    let result = instance.call("nearest", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2512
fn c2494_l2512_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2494_l2512_action_invoke");
    let result = instance.call("nearest", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
    result.map(|_| ())
}

// Line 2513
fn c2495_l2513_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2495_l2513_action_invoke");
    let result = instance.call("nearest", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2514
fn c2496_l2514_action_invoke(instance: &mut Instance) -> Result<(), String> {
    println!("Executing function {}", "c2496_l2514_action_invoke");
    let result = instance.call("nearest", &[Value::F32(f32::INFINITY.to_bits())]);
    assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
    result.map(|_| ())
}

// Line 2515
fn c2497_l2515_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2497_l2515_assert_return_canonical_nan");
    let result = instance.call("nearest", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2497_l2515_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2516
fn c2498_l2516_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2498_l2516_assert_return_arithmetic_nan");
    let result = instance.call("nearest", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2498_l2516_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2517
fn c2499_l2517_assert_return_canonical_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2499_l2517_assert_return_canonical_nan");
    let result = instance.call("nearest", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2499_l2517_assert_return_canonical_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

// Line 2518
fn c2500_l2518_assert_return_arithmetic_nan(instance: &mut Instance) {
    println!("Executing function {}", "c2500_l2518_assert_return_arithmetic_nan");
    let result = instance.call("nearest", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2500_l2518_assert_return_arithmetic_nan");
    assert!(match result {
        Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(),
        Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(),
        _ => unimplemented!()
    })
}

#[test]
fn test_module_1() {
    let mut instance = create_module_1();
    // We group the calls together
    start_module_1(&mut instance);
    c1_l19_action_invoke(&mut instance);
    c2_l20_action_invoke(&mut instance);
    c3_l21_action_invoke(&mut instance);
    c4_l22_action_invoke(&mut instance);
    c5_l23_action_invoke(&mut instance);
    c6_l24_action_invoke(&mut instance);
    c7_l25_action_invoke(&mut instance);
    c8_l26_action_invoke(&mut instance);
    c9_l27_action_invoke(&mut instance);
    c10_l28_action_invoke(&mut instance);
    c11_l29_action_invoke(&mut instance);
    c12_l30_action_invoke(&mut instance);
    c13_l31_action_invoke(&mut instance);
    c14_l32_action_invoke(&mut instance);
    c15_l33_action_invoke(&mut instance);
    c16_l34_action_invoke(&mut instance);
    c17_l35_action_invoke(&mut instance);
    c18_l36_action_invoke(&mut instance);
    c19_l37_action_invoke(&mut instance);
    c20_l38_action_invoke(&mut instance);
    c21_l39_action_invoke(&mut instance);
    c22_l40_action_invoke(&mut instance);
    c23_l41_action_invoke(&mut instance);
    c24_l42_action_invoke(&mut instance);
    c25_l43_action_invoke(&mut instance);
    c26_l44_action_invoke(&mut instance);
    c27_l45_action_invoke(&mut instance);
    c28_l46_action_invoke(&mut instance);
    c29_l47_action_invoke(&mut instance);
    c30_l48_action_invoke(&mut instance);
    c31_l49_action_invoke(&mut instance);
    c32_l50_action_invoke(&mut instance);
    c33_l51_assert_return_canonical_nan(&mut instance);
    c34_l52_assert_return_arithmetic_nan(&mut instance);
    c35_l53_assert_return_canonical_nan(&mut instance);
    c36_l54_assert_return_arithmetic_nan(&mut instance);
    c37_l55_assert_return_canonical_nan(&mut instance);
    c38_l56_assert_return_arithmetic_nan(&mut instance);
    c39_l57_assert_return_canonical_nan(&mut instance);
    c40_l58_assert_return_arithmetic_nan(&mut instance);
    c41_l59_action_invoke(&mut instance);
    c42_l60_action_invoke(&mut instance);
    c43_l61_action_invoke(&mut instance);
    c44_l62_action_invoke(&mut instance);
    c45_l63_action_invoke(&mut instance);
    c46_l64_action_invoke(&mut instance);
    c47_l65_action_invoke(&mut instance);
    c48_l66_action_invoke(&mut instance);
    c49_l67_action_invoke(&mut instance);
    c50_l68_action_invoke(&mut instance);
    c51_l69_action_invoke(&mut instance);
    c52_l70_action_invoke(&mut instance);
    c53_l71_action_invoke(&mut instance);
    c54_l72_action_invoke(&mut instance);
    c55_l73_action_invoke(&mut instance);
    c56_l74_action_invoke(&mut instance);
    c57_l75_action_invoke(&mut instance);
    c58_l76_action_invoke(&mut instance);
    c59_l77_action_invoke(&mut instance);
    c60_l78_action_invoke(&mut instance);
    c61_l79_action_invoke(&mut instance);
    c62_l80_action_invoke(&mut instance);
    c63_l81_action_invoke(&mut instance);
    c64_l82_action_invoke(&mut instance);
    c65_l83_action_invoke(&mut instance);
    c66_l84_action_invoke(&mut instance);
    c67_l85_action_invoke(&mut instance);
    c68_l86_action_invoke(&mut instance);
    c69_l87_action_invoke(&mut instance);
    c70_l88_action_invoke(&mut instance);
    c71_l89_action_invoke(&mut instance);
    c72_l90_action_invoke(&mut instance);
    c73_l91_assert_return_canonical_nan(&mut instance);
    c74_l92_assert_return_arithmetic_nan(&mut instance);
    c75_l93_assert_return_canonical_nan(&mut instance);
    c76_l94_assert_return_arithmetic_nan(&mut instance);
    c77_l95_assert_return_canonical_nan(&mut instance);
    c78_l96_assert_return_arithmetic_nan(&mut instance);
    c79_l97_assert_return_canonical_nan(&mut instance);
    c80_l98_assert_return_arithmetic_nan(&mut instance);
    c81_l99_action_invoke(&mut instance);
    c82_l100_action_invoke(&mut instance);
    c83_l101_action_invoke(&mut instance);
    c84_l102_action_invoke(&mut instance);
    c85_l103_action_invoke(&mut instance);
    c86_l104_action_invoke(&mut instance);
    c87_l105_action_invoke(&mut instance);
    c88_l106_action_invoke(&mut instance);
    c89_l107_action_invoke(&mut instance);
    c90_l108_action_invoke(&mut instance);
    c91_l109_action_invoke(&mut instance);
    c92_l110_action_invoke(&mut instance);
    c93_l111_action_invoke(&mut instance);
    c94_l112_action_invoke(&mut instance);
    c95_l113_action_invoke(&mut instance);
    c96_l114_action_invoke(&mut instance);
    c97_l115_action_invoke(&mut instance);
    c98_l116_action_invoke(&mut instance);
    c99_l117_action_invoke(&mut instance);
    c100_l118_action_invoke(&mut instance);
    c101_l119_action_invoke(&mut instance);
    c102_l120_action_invoke(&mut instance);
    c103_l121_action_invoke(&mut instance);
    c104_l122_action_invoke(&mut instance);
    c105_l123_action_invoke(&mut instance);
    c106_l124_action_invoke(&mut instance);
    c107_l125_action_invoke(&mut instance);
    c108_l126_action_invoke(&mut instance);
    c109_l127_action_invoke(&mut instance);
    c110_l128_action_invoke(&mut instance);
    c111_l129_action_invoke(&mut instance);
    c112_l130_action_invoke(&mut instance);
    c113_l131_assert_return_canonical_nan(&mut instance);
    c114_l132_assert_return_arithmetic_nan(&mut instance);
    c115_l133_assert_return_canonical_nan(&mut instance);
    c116_l134_assert_return_arithmetic_nan(&mut instance);
    c117_l135_assert_return_canonical_nan(&mut instance);
    c118_l136_assert_return_arithmetic_nan(&mut instance);
    c119_l137_assert_return_canonical_nan(&mut instance);
    c120_l138_assert_return_arithmetic_nan(&mut instance);
    c121_l139_action_invoke(&mut instance);
    c122_l140_action_invoke(&mut instance);
    c123_l141_action_invoke(&mut instance);
    c124_l142_action_invoke(&mut instance);
    c125_l143_action_invoke(&mut instance);
    c126_l144_action_invoke(&mut instance);
    c127_l145_action_invoke(&mut instance);
    c128_l146_action_invoke(&mut instance);
    c129_l147_action_invoke(&mut instance);
    c130_l148_action_invoke(&mut instance);
    c131_l149_action_invoke(&mut instance);
    c132_l150_action_invoke(&mut instance);
    c133_l151_action_invoke(&mut instance);
    c134_l152_action_invoke(&mut instance);
    c135_l153_action_invoke(&mut instance);
    c136_l154_action_invoke(&mut instance);
    c137_l155_action_invoke(&mut instance);
    c138_l156_action_invoke(&mut instance);
    c139_l157_action_invoke(&mut instance);
    c140_l158_action_invoke(&mut instance);
    c141_l159_action_invoke(&mut instance);
    c142_l160_action_invoke(&mut instance);
    c143_l161_action_invoke(&mut instance);
    c144_l162_action_invoke(&mut instance);
    c145_l163_action_invoke(&mut instance);
    c146_l164_action_invoke(&mut instance);
    c147_l165_action_invoke(&mut instance);
    c148_l166_action_invoke(&mut instance);
    c149_l167_action_invoke(&mut instance);
    c150_l168_action_invoke(&mut instance);
    c151_l169_action_invoke(&mut instance);
    c152_l170_action_invoke(&mut instance);
    c153_l171_assert_return_canonical_nan(&mut instance);
    c154_l172_assert_return_arithmetic_nan(&mut instance);
    c155_l173_assert_return_canonical_nan(&mut instance);
    c156_l174_assert_return_arithmetic_nan(&mut instance);
    c157_l175_assert_return_canonical_nan(&mut instance);
    c158_l176_assert_return_arithmetic_nan(&mut instance);
    c159_l177_assert_return_canonical_nan(&mut instance);
    c160_l178_assert_return_arithmetic_nan(&mut instance);
    c161_l179_action_invoke(&mut instance);
    c162_l180_action_invoke(&mut instance);
    c163_l181_action_invoke(&mut instance);
    c164_l182_action_invoke(&mut instance);
    c165_l183_action_invoke(&mut instance);
    c166_l184_action_invoke(&mut instance);
    c167_l185_action_invoke(&mut instance);
    c168_l186_action_invoke(&mut instance);
    c169_l187_action_invoke(&mut instance);
    c170_l188_action_invoke(&mut instance);
    c171_l189_action_invoke(&mut instance);
    c172_l190_action_invoke(&mut instance);
    c173_l191_action_invoke(&mut instance);
    c174_l192_action_invoke(&mut instance);
    c175_l193_action_invoke(&mut instance);
    c176_l194_action_invoke(&mut instance);
    c177_l195_action_invoke(&mut instance);
    c178_l196_action_invoke(&mut instance);
    c179_l197_action_invoke(&mut instance);
    c180_l198_action_invoke(&mut instance);
    c181_l199_action_invoke(&mut instance);
    c182_l200_action_invoke(&mut instance);
    c183_l201_action_invoke(&mut instance);
    c184_l202_action_invoke(&mut instance);
    c185_l203_action_invoke(&mut instance);
    c186_l204_action_invoke(&mut instance);
    c187_l205_action_invoke(&mut instance);
    c188_l206_action_invoke(&mut instance);
    c189_l207_action_invoke(&mut instance);
    c190_l208_action_invoke(&mut instance);
    c191_l209_action_invoke(&mut instance);
    c192_l210_action_invoke(&mut instance);
    c193_l211_assert_return_canonical_nan(&mut instance);
    c194_l212_assert_return_arithmetic_nan(&mut instance);
    c195_l213_assert_return_canonical_nan(&mut instance);
    c196_l214_assert_return_arithmetic_nan(&mut instance);
    c197_l215_assert_return_canonical_nan(&mut instance);
    c198_l216_assert_return_arithmetic_nan(&mut instance);
    c199_l217_assert_return_canonical_nan(&mut instance);
    c200_l218_assert_return_arithmetic_nan(&mut instance);
    c201_l219_action_invoke(&mut instance);
    c202_l220_action_invoke(&mut instance);
    c203_l221_action_invoke(&mut instance);
    c204_l222_action_invoke(&mut instance);
    c205_l223_action_invoke(&mut instance);
    c206_l224_action_invoke(&mut instance);
    c207_l225_action_invoke(&mut instance);
    c208_l226_action_invoke(&mut instance);
    c209_l227_action_invoke(&mut instance);
    c210_l228_action_invoke(&mut instance);
    c211_l229_action_invoke(&mut instance);
    c212_l230_action_invoke(&mut instance);
    c213_l231_action_invoke(&mut instance);
    c214_l232_action_invoke(&mut instance);
    c215_l233_action_invoke(&mut instance);
    c216_l234_action_invoke(&mut instance);
    c217_l235_action_invoke(&mut instance);
    c218_l236_action_invoke(&mut instance);
    c219_l237_action_invoke(&mut instance);
    c220_l238_action_invoke(&mut instance);
    c221_l239_action_invoke(&mut instance);
    c222_l240_action_invoke(&mut instance);
    c223_l241_action_invoke(&mut instance);
    c224_l242_action_invoke(&mut instance);
    c225_l243_action_invoke(&mut instance);
    c226_l244_action_invoke(&mut instance);
    c227_l245_action_invoke(&mut instance);
    c228_l246_action_invoke(&mut instance);
    c229_l247_action_invoke(&mut instance);
    c230_l248_action_invoke(&mut instance);
    c231_l249_action_invoke(&mut instance);
    c232_l250_action_invoke(&mut instance);
    c233_l251_assert_return_canonical_nan(&mut instance);
    c234_l252_assert_return_arithmetic_nan(&mut instance);
    c235_l253_assert_return_canonical_nan(&mut instance);
    c236_l254_assert_return_arithmetic_nan(&mut instance);
    c237_l255_assert_return_canonical_nan(&mut instance);
    c238_l256_assert_return_arithmetic_nan(&mut instance);
    c239_l257_assert_return_canonical_nan(&mut instance);
    c240_l258_assert_return_arithmetic_nan(&mut instance);
    c241_l259_action_invoke(&mut instance);
    c242_l260_action_invoke(&mut instance);
    c243_l261_action_invoke(&mut instance);
    c244_l262_action_invoke(&mut instance);
    c245_l263_action_invoke(&mut instance);
    c246_l264_action_invoke(&mut instance);
    c247_l265_action_invoke(&mut instance);
    c248_l266_action_invoke(&mut instance);
    c249_l267_action_invoke(&mut instance);
    c250_l268_action_invoke(&mut instance);
    c251_l269_action_invoke(&mut instance);
    c252_l270_action_invoke(&mut instance);
    c253_l271_action_invoke(&mut instance);
    c254_l272_action_invoke(&mut instance);
    c255_l273_action_invoke(&mut instance);
    c256_l274_action_invoke(&mut instance);
    c257_l275_action_invoke(&mut instance);
    c258_l276_action_invoke(&mut instance);
    c259_l277_action_invoke(&mut instance);
    c260_l278_action_invoke(&mut instance);
    c261_l279_action_invoke(&mut instance);
    c262_l280_action_invoke(&mut instance);
    c263_l281_action_invoke(&mut instance);
    c264_l282_action_invoke(&mut instance);
    c265_l283_action_invoke(&mut instance);
    c266_l284_action_invoke(&mut instance);
    c267_l285_action_invoke(&mut instance);
    c268_l286_action_invoke(&mut instance);
    c269_l287_action_invoke(&mut instance);
    c270_l288_action_invoke(&mut instance);
    c271_l289_action_invoke(&mut instance);
    c272_l290_action_invoke(&mut instance);
    c273_l291_assert_return_canonical_nan(&mut instance);
    c274_l292_assert_return_arithmetic_nan(&mut instance);
    c275_l293_assert_return_canonical_nan(&mut instance);
    c276_l294_assert_return_arithmetic_nan(&mut instance);
    c277_l295_assert_return_canonical_nan(&mut instance);
    c278_l296_assert_return_arithmetic_nan(&mut instance);
    c279_l297_assert_return_canonical_nan(&mut instance);
    c280_l298_assert_return_arithmetic_nan(&mut instance);
    c281_l299_action_invoke(&mut instance);
    c282_l300_action_invoke(&mut instance);
    c283_l301_action_invoke(&mut instance);
    c284_l302_action_invoke(&mut instance);
    c285_l303_action_invoke(&mut instance);
    c286_l304_action_invoke(&mut instance);
    c287_l305_action_invoke(&mut instance);
    c288_l306_action_invoke(&mut instance);
    c289_l307_action_invoke(&mut instance);
    c290_l308_action_invoke(&mut instance);
    c291_l309_action_invoke(&mut instance);
    c292_l310_action_invoke(&mut instance);
    c293_l311_action_invoke(&mut instance);
    c294_l312_action_invoke(&mut instance);
    c295_l313_action_invoke(&mut instance);
    c296_l314_action_invoke(&mut instance);
    c297_l315_action_invoke(&mut instance);
    c298_l316_action_invoke(&mut instance);
    c299_l317_action_invoke(&mut instance);
    c300_l318_action_invoke(&mut instance);
    c301_l319_action_invoke(&mut instance);
    c302_l320_action_invoke(&mut instance);
    c303_l321_action_invoke(&mut instance);
    c304_l322_action_invoke(&mut instance);
    c305_l323_action_invoke(&mut instance);
    c306_l324_action_invoke(&mut instance);
    c307_l325_action_invoke(&mut instance);
    c308_l326_action_invoke(&mut instance);
    c309_l327_action_invoke(&mut instance);
    c310_l328_assert_return_canonical_nan(&mut instance);
    c311_l329_assert_return_canonical_nan(&mut instance);
    c312_l330_action_invoke(&mut instance);
    c313_l331_assert_return_canonical_nan(&mut instance);
    c314_l332_assert_return_arithmetic_nan(&mut instance);
    c315_l333_assert_return_canonical_nan(&mut instance);
    c316_l334_assert_return_arithmetic_nan(&mut instance);
    c317_l335_assert_return_canonical_nan(&mut instance);
    c318_l336_assert_return_arithmetic_nan(&mut instance);
    c319_l337_assert_return_canonical_nan(&mut instance);
    c320_l338_assert_return_arithmetic_nan(&mut instance);
    c321_l339_assert_return_canonical_nan(&mut instance);
    c322_l340_assert_return_arithmetic_nan(&mut instance);
    c323_l341_assert_return_canonical_nan(&mut instance);
    c324_l342_assert_return_arithmetic_nan(&mut instance);
    c325_l343_assert_return_canonical_nan(&mut instance);
    c326_l344_assert_return_arithmetic_nan(&mut instance);
    c327_l345_assert_return_canonical_nan(&mut instance);
    c328_l346_assert_return_arithmetic_nan(&mut instance);
    c329_l347_assert_return_canonical_nan(&mut instance);
    c330_l348_assert_return_arithmetic_nan(&mut instance);
    c331_l349_assert_return_canonical_nan(&mut instance);
    c332_l350_assert_return_arithmetic_nan(&mut instance);
    c333_l351_assert_return_canonical_nan(&mut instance);
    c334_l352_assert_return_arithmetic_nan(&mut instance);
    c335_l353_assert_return_canonical_nan(&mut instance);
    c336_l354_assert_return_arithmetic_nan(&mut instance);
    c337_l355_assert_return_canonical_nan(&mut instance);
    c338_l356_assert_return_arithmetic_nan(&mut instance);
    c339_l357_assert_return_canonical_nan(&mut instance);
    c340_l358_assert_return_arithmetic_nan(&mut instance);
    c341_l359_assert_return_canonical_nan(&mut instance);
    c342_l360_assert_return_arithmetic_nan(&mut instance);
    c343_l361_assert_return_canonical_nan(&mut instance);
    c344_l362_assert_return_arithmetic_nan(&mut instance);
    c345_l363_assert_return_canonical_nan(&mut instance);
    c346_l364_assert_return_arithmetic_nan(&mut instance);
    c347_l365_assert_return_canonical_nan(&mut instance);
    c348_l366_assert_return_arithmetic_nan(&mut instance);
    c349_l367_assert_return_canonical_nan(&mut instance);
    c350_l368_assert_return_arithmetic_nan(&mut instance);
    c351_l369_assert_return_canonical_nan(&mut instance);
    c352_l370_assert_return_arithmetic_nan(&mut instance);
    c353_l371_assert_return_canonical_nan(&mut instance);
    c354_l372_assert_return_arithmetic_nan(&mut instance);
    c355_l373_assert_return_canonical_nan(&mut instance);
    c356_l374_assert_return_arithmetic_nan(&mut instance);
    c357_l375_assert_return_canonical_nan(&mut instance);
    c358_l376_assert_return_arithmetic_nan(&mut instance);
    c359_l377_assert_return_canonical_nan(&mut instance);
    c360_l378_assert_return_arithmetic_nan(&mut instance);
    c361_l379_assert_return_canonical_nan(&mut instance);
    c362_l380_assert_return_arithmetic_nan(&mut instance);
    c363_l381_assert_return_canonical_nan(&mut instance);
    c364_l382_assert_return_arithmetic_nan(&mut instance);
    c365_l383_assert_return_canonical_nan(&mut instance);
    c366_l384_assert_return_arithmetic_nan(&mut instance);
    c367_l385_assert_return_canonical_nan(&mut instance);
    c368_l386_assert_return_arithmetic_nan(&mut instance);
    c369_l387_assert_return_canonical_nan(&mut instance);
    c370_l388_assert_return_arithmetic_nan(&mut instance);
    c371_l389_assert_return_canonical_nan(&mut instance);
    c372_l390_assert_return_arithmetic_nan(&mut instance);
    c373_l391_assert_return_canonical_nan(&mut instance);
    c374_l392_assert_return_arithmetic_nan(&mut instance);
    c375_l393_assert_return_canonical_nan(&mut instance);
    c376_l394_assert_return_arithmetic_nan(&mut instance);
    c377_l395_assert_return_canonical_nan(&mut instance);
    c378_l396_assert_return_arithmetic_nan(&mut instance);
    c379_l397_assert_return_canonical_nan(&mut instance);
    c380_l398_assert_return_arithmetic_nan(&mut instance);
    c381_l399_assert_return_canonical_nan(&mut instance);
    c382_l400_assert_return_arithmetic_nan(&mut instance);
    c383_l401_assert_return_canonical_nan(&mut instance);
    c384_l402_assert_return_arithmetic_nan(&mut instance);
    c385_l403_assert_return_canonical_nan(&mut instance);
    c386_l404_assert_return_arithmetic_nan(&mut instance);
    c387_l405_assert_return_arithmetic_nan(&mut instance);
    c388_l406_assert_return_arithmetic_nan(&mut instance);
    c389_l407_assert_return_canonical_nan(&mut instance);
    c390_l408_assert_return_arithmetic_nan(&mut instance);
    c391_l409_assert_return_arithmetic_nan(&mut instance);
    c392_l410_assert_return_arithmetic_nan(&mut instance);
    c393_l411_assert_return_canonical_nan(&mut instance);
    c394_l412_assert_return_arithmetic_nan(&mut instance);
    c395_l413_assert_return_arithmetic_nan(&mut instance);
    c396_l414_assert_return_arithmetic_nan(&mut instance);
    c397_l415_assert_return_canonical_nan(&mut instance);
    c398_l416_assert_return_arithmetic_nan(&mut instance);
    c399_l417_assert_return_arithmetic_nan(&mut instance);
    c400_l418_assert_return_arithmetic_nan(&mut instance);
    c401_l419_action_invoke(&mut instance);
    c402_l420_action_invoke(&mut instance);
    c403_l421_action_invoke(&mut instance);
    c404_l422_action_invoke(&mut instance);
    c405_l423_action_invoke(&mut instance);
    c406_l424_action_invoke(&mut instance);
    c407_l425_action_invoke(&mut instance);
    c408_l426_action_invoke(&mut instance);
    c409_l427_action_invoke(&mut instance);
    c410_l428_action_invoke(&mut instance);
    c411_l429_action_invoke(&mut instance);
    c412_l430_action_invoke(&mut instance);
    c413_l431_action_invoke(&mut instance);
    c414_l432_action_invoke(&mut instance);
    c415_l433_action_invoke(&mut instance);
    c416_l434_action_invoke(&mut instance);
    c417_l435_action_invoke(&mut instance);
    c418_l436_action_invoke(&mut instance);
    c419_l437_action_invoke(&mut instance);
    c420_l438_action_invoke(&mut instance);
    c421_l439_action_invoke(&mut instance);
    c422_l440_action_invoke(&mut instance);
    c423_l441_action_invoke(&mut instance);
    c424_l442_action_invoke(&mut instance);
    c425_l443_action_invoke(&mut instance);
    c426_l444_action_invoke(&mut instance);
    c427_l445_action_invoke(&mut instance);
    c428_l446_action_invoke(&mut instance);
    c429_l447_action_invoke(&mut instance);
    c430_l448_action_invoke(&mut instance);
    c431_l449_action_invoke(&mut instance);
    c432_l450_action_invoke(&mut instance);
    c433_l451_assert_return_canonical_nan(&mut instance);
    c434_l452_assert_return_arithmetic_nan(&mut instance);
    c435_l453_assert_return_canonical_nan(&mut instance);
    c436_l454_assert_return_arithmetic_nan(&mut instance);
    c437_l455_assert_return_canonical_nan(&mut instance);
    c438_l456_assert_return_arithmetic_nan(&mut instance);
    c439_l457_assert_return_canonical_nan(&mut instance);
    c440_l458_assert_return_arithmetic_nan(&mut instance);
    c441_l459_action_invoke(&mut instance);
    c442_l460_action_invoke(&mut instance);
    c443_l461_action_invoke(&mut instance);
    c444_l462_action_invoke(&mut instance);
    c445_l463_action_invoke(&mut instance);
    c446_l464_action_invoke(&mut instance);
    c447_l465_action_invoke(&mut instance);
    c448_l466_action_invoke(&mut instance);
    c449_l467_action_invoke(&mut instance);
    c450_l468_action_invoke(&mut instance);
    c451_l469_action_invoke(&mut instance);
    c452_l470_action_invoke(&mut instance);
    c453_l471_action_invoke(&mut instance);
    c454_l472_action_invoke(&mut instance);
    c455_l473_action_invoke(&mut instance);
    c456_l474_action_invoke(&mut instance);
    c457_l475_action_invoke(&mut instance);
    c458_l476_action_invoke(&mut instance);
    c459_l477_action_invoke(&mut instance);
    c460_l478_action_invoke(&mut instance);
    c461_l479_action_invoke(&mut instance);
    c462_l480_action_invoke(&mut instance);
    c463_l481_action_invoke(&mut instance);
    c464_l482_action_invoke(&mut instance);
    c465_l483_action_invoke(&mut instance);
    c466_l484_action_invoke(&mut instance);
    c467_l485_action_invoke(&mut instance);
    c468_l486_action_invoke(&mut instance);
    c469_l487_action_invoke(&mut instance);
    c470_l488_action_invoke(&mut instance);
    c471_l489_action_invoke(&mut instance);
    c472_l490_action_invoke(&mut instance);
    c473_l491_assert_return_canonical_nan(&mut instance);
    c474_l492_assert_return_arithmetic_nan(&mut instance);
    c475_l493_assert_return_canonical_nan(&mut instance);
    c476_l494_assert_return_arithmetic_nan(&mut instance);
    c477_l495_assert_return_canonical_nan(&mut instance);
    c478_l496_assert_return_arithmetic_nan(&mut instance);
    c479_l497_assert_return_canonical_nan(&mut instance);
    c480_l498_assert_return_arithmetic_nan(&mut instance);
    c481_l499_action_invoke(&mut instance);
    c482_l500_action_invoke(&mut instance);
    c483_l501_action_invoke(&mut instance);
    c484_l502_action_invoke(&mut instance);
    c485_l503_action_invoke(&mut instance);
    c486_l504_action_invoke(&mut instance);
    c487_l505_action_invoke(&mut instance);
    c488_l506_action_invoke(&mut instance);
    c489_l507_action_invoke(&mut instance);
    c490_l508_action_invoke(&mut instance);
    c491_l509_action_invoke(&mut instance);
    c492_l510_action_invoke(&mut instance);
    c493_l511_action_invoke(&mut instance);
    c494_l512_action_invoke(&mut instance);
    c495_l513_action_invoke(&mut instance);
    c496_l514_action_invoke(&mut instance);
    c497_l515_action_invoke(&mut instance);
    c498_l516_action_invoke(&mut instance);
    c499_l517_action_invoke(&mut instance);
    c500_l518_action_invoke(&mut instance);
    c501_l519_action_invoke(&mut instance);
    c502_l520_action_invoke(&mut instance);
    c503_l521_action_invoke(&mut instance);
    c504_l522_action_invoke(&mut instance);
    c505_l523_action_invoke(&mut instance);
    c506_l524_action_invoke(&mut instance);
    c507_l525_action_invoke(&mut instance);
    c508_l526_action_invoke(&mut instance);
    c509_l527_action_invoke(&mut instance);
    c510_l528_action_invoke(&mut instance);
    c511_l529_action_invoke(&mut instance);
    c512_l530_action_invoke(&mut instance);
    c513_l531_assert_return_canonical_nan(&mut instance);
    c514_l532_assert_return_arithmetic_nan(&mut instance);
    c515_l533_assert_return_canonical_nan(&mut instance);
    c516_l534_assert_return_arithmetic_nan(&mut instance);
    c517_l535_assert_return_canonical_nan(&mut instance);
    c518_l536_assert_return_arithmetic_nan(&mut instance);
    c519_l537_assert_return_canonical_nan(&mut instance);
    c520_l538_assert_return_arithmetic_nan(&mut instance);
    c521_l539_action_invoke(&mut instance);
    c522_l540_action_invoke(&mut instance);
    c523_l541_action_invoke(&mut instance);
    c524_l542_action_invoke(&mut instance);
    c525_l543_action_invoke(&mut instance);
    c526_l544_action_invoke(&mut instance);
    c527_l545_action_invoke(&mut instance);
    c528_l546_action_invoke(&mut instance);
    c529_l547_action_invoke(&mut instance);
    c530_l548_action_invoke(&mut instance);
    c531_l549_action_invoke(&mut instance);
    c532_l550_action_invoke(&mut instance);
    c533_l551_action_invoke(&mut instance);
    c534_l552_action_invoke(&mut instance);
    c535_l553_action_invoke(&mut instance);
    c536_l554_action_invoke(&mut instance);
    c537_l555_action_invoke(&mut instance);
    c538_l556_action_invoke(&mut instance);
    c539_l557_action_invoke(&mut instance);
    c540_l558_action_invoke(&mut instance);
    c541_l559_action_invoke(&mut instance);
    c542_l560_action_invoke(&mut instance);
    c543_l561_action_invoke(&mut instance);
    c544_l562_action_invoke(&mut instance);
    c545_l563_action_invoke(&mut instance);
    c546_l564_action_invoke(&mut instance);
    c547_l565_action_invoke(&mut instance);
    c548_l566_action_invoke(&mut instance);
    c549_l567_action_invoke(&mut instance);
    c550_l568_action_invoke(&mut instance);
    c551_l569_action_invoke(&mut instance);
    c552_l570_action_invoke(&mut instance);
    c553_l571_assert_return_canonical_nan(&mut instance);
    c554_l572_assert_return_arithmetic_nan(&mut instance);
    c555_l573_assert_return_canonical_nan(&mut instance);
    c556_l574_assert_return_arithmetic_nan(&mut instance);
    c557_l575_assert_return_canonical_nan(&mut instance);
    c558_l576_assert_return_arithmetic_nan(&mut instance);
    c559_l577_assert_return_canonical_nan(&mut instance);
    c560_l578_assert_return_arithmetic_nan(&mut instance);
    c561_l579_action_invoke(&mut instance);
    c562_l580_action_invoke(&mut instance);
    c563_l581_action_invoke(&mut instance);
    c564_l582_action_invoke(&mut instance);
    c565_l583_action_invoke(&mut instance);
    c566_l584_action_invoke(&mut instance);
    c567_l585_action_invoke(&mut instance);
    c568_l586_action_invoke(&mut instance);
    c569_l587_action_invoke(&mut instance);
    c570_l588_action_invoke(&mut instance);
    c571_l589_action_invoke(&mut instance);
    c572_l590_action_invoke(&mut instance);
    c573_l591_action_invoke(&mut instance);
    c574_l592_action_invoke(&mut instance);
    c575_l593_action_invoke(&mut instance);
    c576_l594_action_invoke(&mut instance);
    c577_l595_action_invoke(&mut instance);
    c578_l596_action_invoke(&mut instance);
    c579_l597_action_invoke(&mut instance);
    c580_l598_action_invoke(&mut instance);
    c581_l599_action_invoke(&mut instance);
    c582_l600_action_invoke(&mut instance);
    c583_l601_action_invoke(&mut instance);
    c584_l602_action_invoke(&mut instance);
    c585_l603_action_invoke(&mut instance);
    c586_l604_action_invoke(&mut instance);
    c587_l605_action_invoke(&mut instance);
    c588_l606_action_invoke(&mut instance);
    c589_l607_action_invoke(&mut instance);
    c590_l608_action_invoke(&mut instance);
    c591_l609_action_invoke(&mut instance);
    c592_l610_action_invoke(&mut instance);
    c593_l611_assert_return_canonical_nan(&mut instance);
    c594_l612_assert_return_arithmetic_nan(&mut instance);
    c595_l613_assert_return_canonical_nan(&mut instance);
    c596_l614_assert_return_arithmetic_nan(&mut instance);
    c597_l615_assert_return_canonical_nan(&mut instance);
    c598_l616_assert_return_arithmetic_nan(&mut instance);
    c599_l617_assert_return_canonical_nan(&mut instance);
    c600_l618_assert_return_arithmetic_nan(&mut instance);
    c601_l619_action_invoke(&mut instance);
    c602_l620_action_invoke(&mut instance);
    c603_l621_action_invoke(&mut instance);
    c604_l622_action_invoke(&mut instance);
    c605_l623_action_invoke(&mut instance);
    c606_l624_action_invoke(&mut instance);
    c607_l625_action_invoke(&mut instance);
    c608_l626_action_invoke(&mut instance);
    c609_l627_action_invoke(&mut instance);
    c610_l628_action_invoke(&mut instance);
    c611_l629_action_invoke(&mut instance);
    c612_l630_action_invoke(&mut instance);
    c613_l631_action_invoke(&mut instance);
    c614_l632_action_invoke(&mut instance);
    c615_l633_action_invoke(&mut instance);
    c616_l634_action_invoke(&mut instance);
    c617_l635_action_invoke(&mut instance);
    c618_l636_action_invoke(&mut instance);
    c619_l637_action_invoke(&mut instance);
    c620_l638_action_invoke(&mut instance);
    c621_l639_action_invoke(&mut instance);
    c622_l640_action_invoke(&mut instance);
    c623_l641_action_invoke(&mut instance);
    c624_l642_action_invoke(&mut instance);
    c625_l643_action_invoke(&mut instance);
    c626_l644_action_invoke(&mut instance);
    c627_l645_action_invoke(&mut instance);
    c628_l646_action_invoke(&mut instance);
    c629_l647_action_invoke(&mut instance);
    c630_l648_action_invoke(&mut instance);
    c631_l649_action_invoke(&mut instance);
    c632_l650_action_invoke(&mut instance);
    c633_l651_assert_return_canonical_nan(&mut instance);
    c634_l652_assert_return_arithmetic_nan(&mut instance);
    c635_l653_assert_return_canonical_nan(&mut instance);
    c636_l654_assert_return_arithmetic_nan(&mut instance);
    c637_l655_assert_return_canonical_nan(&mut instance);
    c638_l656_assert_return_arithmetic_nan(&mut instance);
    c639_l657_assert_return_canonical_nan(&mut instance);
    c640_l658_assert_return_arithmetic_nan(&mut instance);
    c641_l659_action_invoke(&mut instance);
    c642_l660_action_invoke(&mut instance);
    c643_l661_action_invoke(&mut instance);
    c644_l662_action_invoke(&mut instance);
    c645_l663_action_invoke(&mut instance);
    c646_l664_action_invoke(&mut instance);
    c647_l665_action_invoke(&mut instance);
    c648_l666_action_invoke(&mut instance);
    c649_l667_action_invoke(&mut instance);
    c650_l668_action_invoke(&mut instance);
    c651_l669_action_invoke(&mut instance);
    c652_l670_action_invoke(&mut instance);
    c653_l671_action_invoke(&mut instance);
    c654_l672_action_invoke(&mut instance);
    c655_l673_action_invoke(&mut instance);
    c656_l674_action_invoke(&mut instance);
    c657_l675_action_invoke(&mut instance);
    c658_l676_action_invoke(&mut instance);
    c659_l677_action_invoke(&mut instance);
    c660_l678_action_invoke(&mut instance);
    c661_l679_action_invoke(&mut instance);
    c662_l680_action_invoke(&mut instance);
    c663_l681_action_invoke(&mut instance);
    c664_l682_action_invoke(&mut instance);
    c665_l683_action_invoke(&mut instance);
    c666_l684_action_invoke(&mut instance);
    c667_l685_action_invoke(&mut instance);
    c668_l686_action_invoke(&mut instance);
    c669_l687_action_invoke(&mut instance);
    c670_l688_action_invoke(&mut instance);
    c671_l689_action_invoke(&mut instance);
    c672_l690_action_invoke(&mut instance);
    c673_l691_assert_return_canonical_nan(&mut instance);
    c674_l692_assert_return_arithmetic_nan(&mut instance);
    c675_l693_assert_return_canonical_nan(&mut instance);
    c676_l694_assert_return_arithmetic_nan(&mut instance);
    c677_l695_assert_return_canonical_nan(&mut instance);
    c678_l696_assert_return_arithmetic_nan(&mut instance);
    c679_l697_assert_return_canonical_nan(&mut instance);
    c680_l698_assert_return_arithmetic_nan(&mut instance);
    c681_l699_action_invoke(&mut instance);
    c682_l700_action_invoke(&mut instance);
    c683_l701_action_invoke(&mut instance);
    c684_l702_action_invoke(&mut instance);
    c685_l703_action_invoke(&mut instance);
    c686_l704_action_invoke(&mut instance);
    c687_l705_action_invoke(&mut instance);
    c688_l706_action_invoke(&mut instance);
    c689_l707_action_invoke(&mut instance);
    c690_l708_action_invoke(&mut instance);
    c691_l709_action_invoke(&mut instance);
    c692_l710_action_invoke(&mut instance);
    c693_l711_action_invoke(&mut instance);
    c694_l712_action_invoke(&mut instance);
    c695_l713_action_invoke(&mut instance);
    c696_l714_action_invoke(&mut instance);
    c697_l715_action_invoke(&mut instance);
    c698_l716_action_invoke(&mut instance);
    c699_l717_action_invoke(&mut instance);
    c700_l718_action_invoke(&mut instance);
    c701_l719_action_invoke(&mut instance);
    c702_l720_action_invoke(&mut instance);
    c703_l721_action_invoke(&mut instance);
    c704_l722_action_invoke(&mut instance);
    c705_l723_action_invoke(&mut instance);
    c706_l724_action_invoke(&mut instance);
    c707_l725_action_invoke(&mut instance);
    c708_l726_action_invoke(&mut instance);
    c709_l727_assert_return_canonical_nan(&mut instance);
    c710_l728_action_invoke(&mut instance);
    c711_l729_action_invoke(&mut instance);
    c712_l730_assert_return_canonical_nan(&mut instance);
    c713_l731_assert_return_canonical_nan(&mut instance);
    c714_l732_assert_return_arithmetic_nan(&mut instance);
    c715_l733_assert_return_canonical_nan(&mut instance);
    c716_l734_assert_return_arithmetic_nan(&mut instance);
    c717_l735_assert_return_canonical_nan(&mut instance);
    c718_l736_assert_return_arithmetic_nan(&mut instance);
    c719_l737_assert_return_canonical_nan(&mut instance);
    c720_l738_assert_return_arithmetic_nan(&mut instance);
    c721_l739_assert_return_canonical_nan(&mut instance);
    c722_l740_assert_return_arithmetic_nan(&mut instance);
    c723_l741_assert_return_canonical_nan(&mut instance);
    c724_l742_assert_return_arithmetic_nan(&mut instance);
    c725_l743_assert_return_canonical_nan(&mut instance);
    c726_l744_assert_return_arithmetic_nan(&mut instance);
    c727_l745_assert_return_canonical_nan(&mut instance);
    c728_l746_assert_return_arithmetic_nan(&mut instance);
    c729_l747_assert_return_canonical_nan(&mut instance);
    c730_l748_assert_return_arithmetic_nan(&mut instance);
    c731_l749_assert_return_canonical_nan(&mut instance);
    c732_l750_assert_return_arithmetic_nan(&mut instance);
    c733_l751_assert_return_canonical_nan(&mut instance);
    c734_l752_assert_return_arithmetic_nan(&mut instance);
    c735_l753_assert_return_canonical_nan(&mut instance);
    c736_l754_assert_return_arithmetic_nan(&mut instance);
    c737_l755_assert_return_canonical_nan(&mut instance);
    c738_l756_assert_return_arithmetic_nan(&mut instance);
    c739_l757_assert_return_canonical_nan(&mut instance);
    c740_l758_assert_return_arithmetic_nan(&mut instance);
    c741_l759_assert_return_canonical_nan(&mut instance);
    c742_l760_assert_return_arithmetic_nan(&mut instance);
    c743_l761_assert_return_canonical_nan(&mut instance);
    c744_l762_assert_return_arithmetic_nan(&mut instance);
    c745_l763_assert_return_canonical_nan(&mut instance);
    c746_l764_assert_return_arithmetic_nan(&mut instance);
    c747_l765_assert_return_canonical_nan(&mut instance);
    c748_l766_assert_return_arithmetic_nan(&mut instance);
    c749_l767_assert_return_canonical_nan(&mut instance);
    c750_l768_assert_return_arithmetic_nan(&mut instance);
    c751_l769_assert_return_canonical_nan(&mut instance);
    c752_l770_assert_return_arithmetic_nan(&mut instance);
    c753_l771_assert_return_canonical_nan(&mut instance);
    c754_l772_assert_return_arithmetic_nan(&mut instance);
    c755_l773_assert_return_canonical_nan(&mut instance);
    c756_l774_assert_return_arithmetic_nan(&mut instance);
    c757_l775_assert_return_canonical_nan(&mut instance);
    c758_l776_assert_return_arithmetic_nan(&mut instance);
    c759_l777_assert_return_canonical_nan(&mut instance);
    c760_l778_assert_return_arithmetic_nan(&mut instance);
    c761_l779_assert_return_canonical_nan(&mut instance);
    c762_l780_assert_return_arithmetic_nan(&mut instance);
    c763_l781_assert_return_canonical_nan(&mut instance);
    c764_l782_assert_return_arithmetic_nan(&mut instance);
    c765_l783_assert_return_canonical_nan(&mut instance);
    c766_l784_assert_return_arithmetic_nan(&mut instance);
    c767_l785_assert_return_canonical_nan(&mut instance);
    c768_l786_assert_return_arithmetic_nan(&mut instance);
    c769_l787_assert_return_canonical_nan(&mut instance);
    c770_l788_assert_return_arithmetic_nan(&mut instance);
    c771_l789_assert_return_canonical_nan(&mut instance);
    c772_l790_assert_return_arithmetic_nan(&mut instance);
    c773_l791_assert_return_canonical_nan(&mut instance);
    c774_l792_assert_return_arithmetic_nan(&mut instance);
    c775_l793_assert_return_canonical_nan(&mut instance);
    c776_l794_assert_return_arithmetic_nan(&mut instance);
    c777_l795_assert_return_canonical_nan(&mut instance);
    c778_l796_assert_return_arithmetic_nan(&mut instance);
    c779_l797_assert_return_canonical_nan(&mut instance);
    c780_l798_assert_return_arithmetic_nan(&mut instance);
    c781_l799_assert_return_canonical_nan(&mut instance);
    c782_l800_assert_return_arithmetic_nan(&mut instance);
    c783_l801_assert_return_canonical_nan(&mut instance);
    c784_l802_assert_return_arithmetic_nan(&mut instance);
    c785_l803_assert_return_canonical_nan(&mut instance);
    c786_l804_assert_return_arithmetic_nan(&mut instance);
    c787_l805_assert_return_arithmetic_nan(&mut instance);
    c788_l806_assert_return_arithmetic_nan(&mut instance);
    c789_l807_assert_return_canonical_nan(&mut instance);
    c790_l808_assert_return_arithmetic_nan(&mut instance);
    c791_l809_assert_return_arithmetic_nan(&mut instance);
    c792_l810_assert_return_arithmetic_nan(&mut instance);
    c793_l811_assert_return_canonical_nan(&mut instance);
    c794_l812_assert_return_arithmetic_nan(&mut instance);
    c795_l813_assert_return_arithmetic_nan(&mut instance);
    c796_l814_assert_return_arithmetic_nan(&mut instance);
    c797_l815_assert_return_canonical_nan(&mut instance);
    c798_l816_assert_return_arithmetic_nan(&mut instance);
    c799_l817_assert_return_arithmetic_nan(&mut instance);
    c800_l818_assert_return_arithmetic_nan(&mut instance);
    c801_l819_action_invoke(&mut instance);
    c802_l820_action_invoke(&mut instance);
    c803_l821_action_invoke(&mut instance);
    c804_l822_action_invoke(&mut instance);
    c805_l823_action_invoke(&mut instance);
    c806_l824_action_invoke(&mut instance);
    c807_l825_action_invoke(&mut instance);
    c808_l826_action_invoke(&mut instance);
    c809_l827_action_invoke(&mut instance);
    c810_l828_action_invoke(&mut instance);
    c811_l829_action_invoke(&mut instance);
    c812_l830_action_invoke(&mut instance);
    c813_l831_action_invoke(&mut instance);
    c814_l832_action_invoke(&mut instance);
    c815_l833_action_invoke(&mut instance);
    c816_l834_action_invoke(&mut instance);
    c817_l835_action_invoke(&mut instance);
    c818_l836_action_invoke(&mut instance);
    c819_l837_action_invoke(&mut instance);
    c820_l838_action_invoke(&mut instance);
    c821_l839_action_invoke(&mut instance);
    c822_l840_action_invoke(&mut instance);
    c823_l841_action_invoke(&mut instance);
    c824_l842_action_invoke(&mut instance);
    c825_l843_action_invoke(&mut instance);
    c826_l844_action_invoke(&mut instance);
    c827_l845_action_invoke(&mut instance);
    c828_l846_action_invoke(&mut instance);
    c829_l847_assert_return_canonical_nan(&mut instance);
    c830_l848_assert_return_canonical_nan(&mut instance);
    c831_l849_assert_return_canonical_nan(&mut instance);
    c832_l850_assert_return_canonical_nan(&mut instance);
    c833_l851_assert_return_canonical_nan(&mut instance);
    c834_l852_assert_return_arithmetic_nan(&mut instance);
    c835_l853_assert_return_canonical_nan(&mut instance);
    c836_l854_assert_return_arithmetic_nan(&mut instance);
    c837_l855_assert_return_canonical_nan(&mut instance);
    c838_l856_assert_return_arithmetic_nan(&mut instance);
    c839_l857_assert_return_canonical_nan(&mut instance);
    c840_l858_assert_return_arithmetic_nan(&mut instance);
    c841_l859_action_invoke(&mut instance);
    c842_l860_action_invoke(&mut instance);
    c843_l861_action_invoke(&mut instance);
    c844_l862_action_invoke(&mut instance);
    c845_l863_action_invoke(&mut instance);
    c846_l864_action_invoke(&mut instance);
    c847_l865_action_invoke(&mut instance);
    c848_l866_action_invoke(&mut instance);
    c849_l867_action_invoke(&mut instance);
    c850_l868_action_invoke(&mut instance);
    c851_l869_action_invoke(&mut instance);
    c852_l870_action_invoke(&mut instance);
    c853_l871_action_invoke(&mut instance);
    c854_l872_action_invoke(&mut instance);
    c855_l873_action_invoke(&mut instance);
    c856_l874_action_invoke(&mut instance);
    c857_l875_action_invoke(&mut instance);
    c858_l876_action_invoke(&mut instance);
    c859_l877_action_invoke(&mut instance);
    c860_l878_action_invoke(&mut instance);
    c861_l879_action_invoke(&mut instance);
    c862_l880_action_invoke(&mut instance);
    c863_l881_action_invoke(&mut instance);
    c864_l882_action_invoke(&mut instance);
    c865_l883_action_invoke(&mut instance);
    c866_l884_action_invoke(&mut instance);
    c867_l885_action_invoke(&mut instance);
    c868_l886_action_invoke(&mut instance);
    c869_l887_action_invoke(&mut instance);
    c870_l888_action_invoke(&mut instance);
    c871_l889_action_invoke(&mut instance);
    c872_l890_action_invoke(&mut instance);
    c873_l891_assert_return_canonical_nan(&mut instance);
    c874_l892_assert_return_arithmetic_nan(&mut instance);
    c875_l893_assert_return_canonical_nan(&mut instance);
    c876_l894_assert_return_arithmetic_nan(&mut instance);
    c877_l895_assert_return_canonical_nan(&mut instance);
    c878_l896_assert_return_arithmetic_nan(&mut instance);
    c879_l897_assert_return_canonical_nan(&mut instance);
    c880_l898_assert_return_arithmetic_nan(&mut instance);
    c881_l899_action_invoke(&mut instance);
    c882_l900_action_invoke(&mut instance);
    c883_l901_action_invoke(&mut instance);
    c884_l902_action_invoke(&mut instance);
    c885_l903_action_invoke(&mut instance);
    c886_l904_action_invoke(&mut instance);
    c887_l905_action_invoke(&mut instance);
    c888_l906_action_invoke(&mut instance);
    c889_l907_action_invoke(&mut instance);
    c890_l908_action_invoke(&mut instance);
    c891_l909_action_invoke(&mut instance);
    c892_l910_action_invoke(&mut instance);
    c893_l911_action_invoke(&mut instance);
    c894_l912_action_invoke(&mut instance);
    c895_l913_action_invoke(&mut instance);
    c896_l914_action_invoke(&mut instance);
    c897_l915_action_invoke(&mut instance);
    c898_l916_action_invoke(&mut instance);
    c899_l917_action_invoke(&mut instance);
    c900_l918_action_invoke(&mut instance);
    c901_l919_action_invoke(&mut instance);
    c902_l920_action_invoke(&mut instance);
    c903_l921_action_invoke(&mut instance);
    c904_l922_action_invoke(&mut instance);
    c905_l923_action_invoke(&mut instance);
    c906_l924_action_invoke(&mut instance);
    c907_l925_action_invoke(&mut instance);
    c908_l926_action_invoke(&mut instance);
    c909_l927_action_invoke(&mut instance);
    c910_l928_action_invoke(&mut instance);
    c911_l929_action_invoke(&mut instance);
    c912_l930_action_invoke(&mut instance);
    c913_l931_assert_return_canonical_nan(&mut instance);
    c914_l932_assert_return_arithmetic_nan(&mut instance);
    c915_l933_assert_return_canonical_nan(&mut instance);
    c916_l934_assert_return_arithmetic_nan(&mut instance);
    c917_l935_assert_return_canonical_nan(&mut instance);
    c918_l936_assert_return_arithmetic_nan(&mut instance);
    c919_l937_assert_return_canonical_nan(&mut instance);
    c920_l938_assert_return_arithmetic_nan(&mut instance);
    c921_l939_action_invoke(&mut instance);
    c922_l940_action_invoke(&mut instance);
    c923_l941_action_invoke(&mut instance);
    c924_l942_action_invoke(&mut instance);
    c925_l943_action_invoke(&mut instance);
    c926_l944_action_invoke(&mut instance);
    c927_l945_action_invoke(&mut instance);
    c928_l946_action_invoke(&mut instance);
    c929_l947_action_invoke(&mut instance);
    c930_l948_action_invoke(&mut instance);
    c931_l949_action_invoke(&mut instance);
    c932_l950_action_invoke(&mut instance);
    c933_l951_action_invoke(&mut instance);
    c934_l952_action_invoke(&mut instance);
    c935_l953_action_invoke(&mut instance);
    c936_l954_action_invoke(&mut instance);
    c937_l955_action_invoke(&mut instance);
    c938_l956_action_invoke(&mut instance);
    c939_l957_action_invoke(&mut instance);
    c940_l958_action_invoke(&mut instance);
    c941_l959_action_invoke(&mut instance);
    c942_l960_action_invoke(&mut instance);
    c943_l961_action_invoke(&mut instance);
    c944_l962_action_invoke(&mut instance);
    c945_l963_action_invoke(&mut instance);
    c946_l964_action_invoke(&mut instance);
    c947_l965_action_invoke(&mut instance);
    c948_l966_action_invoke(&mut instance);
    c949_l967_action_invoke(&mut instance);
    c950_l968_action_invoke(&mut instance);
    c951_l969_action_invoke(&mut instance);
    c952_l970_action_invoke(&mut instance);
    c953_l971_assert_return_canonical_nan(&mut instance);
    c954_l972_assert_return_arithmetic_nan(&mut instance);
    c955_l973_assert_return_canonical_nan(&mut instance);
    c956_l974_assert_return_arithmetic_nan(&mut instance);
    c957_l975_assert_return_canonical_nan(&mut instance);
    c958_l976_assert_return_arithmetic_nan(&mut instance);
    c959_l977_assert_return_canonical_nan(&mut instance);
    c960_l978_assert_return_arithmetic_nan(&mut instance);
    c961_l979_action_invoke(&mut instance);
    c962_l980_action_invoke(&mut instance);
    c963_l981_action_invoke(&mut instance);
    c964_l982_action_invoke(&mut instance);
    c965_l983_action_invoke(&mut instance);
    c966_l984_action_invoke(&mut instance);
    c967_l985_action_invoke(&mut instance);
    c968_l986_action_invoke(&mut instance);
    c969_l987_action_invoke(&mut instance);
    c970_l988_action_invoke(&mut instance);
    c971_l989_action_invoke(&mut instance);
    c972_l990_action_invoke(&mut instance);
    c973_l991_action_invoke(&mut instance);
    c974_l992_action_invoke(&mut instance);
    c975_l993_action_invoke(&mut instance);
    c976_l994_action_invoke(&mut instance);
    c977_l995_action_invoke(&mut instance);
    c978_l996_action_invoke(&mut instance);
    c979_l997_action_invoke(&mut instance);
    c980_l998_action_invoke(&mut instance);
    c981_l999_action_invoke(&mut instance);
    c982_l1000_action_invoke(&mut instance);
    c983_l1001_action_invoke(&mut instance);
    c984_l1002_action_invoke(&mut instance);
    c985_l1003_action_invoke(&mut instance);
    c986_l1004_action_invoke(&mut instance);
    c987_l1005_action_invoke(&mut instance);
    c988_l1006_action_invoke(&mut instance);
    c989_l1007_action_invoke(&mut instance);
    c990_l1008_action_invoke(&mut instance);
    c991_l1009_action_invoke(&mut instance);
    c992_l1010_action_invoke(&mut instance);
    c993_l1011_assert_return_canonical_nan(&mut instance);
    c994_l1012_assert_return_arithmetic_nan(&mut instance);
    c995_l1013_assert_return_canonical_nan(&mut instance);
    c996_l1014_assert_return_arithmetic_nan(&mut instance);
    c997_l1015_assert_return_canonical_nan(&mut instance);
    c998_l1016_assert_return_arithmetic_nan(&mut instance);
    c999_l1017_assert_return_canonical_nan(&mut instance);
    c1000_l1018_assert_return_arithmetic_nan(&mut instance);
    c1001_l1019_action_invoke(&mut instance);
    c1002_l1020_action_invoke(&mut instance);
    c1003_l1021_action_invoke(&mut instance);
    c1004_l1022_action_invoke(&mut instance);
    c1005_l1023_action_invoke(&mut instance);
    c1006_l1024_action_invoke(&mut instance);
    c1007_l1025_action_invoke(&mut instance);
    c1008_l1026_action_invoke(&mut instance);
    c1009_l1027_action_invoke(&mut instance);
    c1010_l1028_action_invoke(&mut instance);
    c1011_l1029_action_invoke(&mut instance);
    c1012_l1030_action_invoke(&mut instance);
    c1013_l1031_action_invoke(&mut instance);
    c1014_l1032_action_invoke(&mut instance);
    c1015_l1033_action_invoke(&mut instance);
    c1016_l1034_action_invoke(&mut instance);
    c1017_l1035_action_invoke(&mut instance);
    c1018_l1036_action_invoke(&mut instance);
    c1019_l1037_action_invoke(&mut instance);
    c1020_l1038_action_invoke(&mut instance);
    c1021_l1039_action_invoke(&mut instance);
    c1022_l1040_action_invoke(&mut instance);
    c1023_l1041_action_invoke(&mut instance);
    c1024_l1042_action_invoke(&mut instance);
    c1025_l1043_action_invoke(&mut instance);
    c1026_l1044_action_invoke(&mut instance);
    c1027_l1045_action_invoke(&mut instance);
    c1028_l1046_action_invoke(&mut instance);
    c1029_l1047_action_invoke(&mut instance);
    c1030_l1048_action_invoke(&mut instance);
    c1031_l1049_action_invoke(&mut instance);
    c1032_l1050_action_invoke(&mut instance);
    c1033_l1051_assert_return_canonical_nan(&mut instance);
    c1034_l1052_assert_return_arithmetic_nan(&mut instance);
    c1035_l1053_assert_return_canonical_nan(&mut instance);
    c1036_l1054_assert_return_arithmetic_nan(&mut instance);
    c1037_l1055_assert_return_canonical_nan(&mut instance);
    c1038_l1056_assert_return_arithmetic_nan(&mut instance);
    c1039_l1057_assert_return_canonical_nan(&mut instance);
    c1040_l1058_assert_return_arithmetic_nan(&mut instance);
    c1041_l1059_action_invoke(&mut instance);
    c1042_l1060_action_invoke(&mut instance);
    c1043_l1061_action_invoke(&mut instance);
    c1044_l1062_action_invoke(&mut instance);
    c1045_l1063_action_invoke(&mut instance);
    c1046_l1064_action_invoke(&mut instance);
    c1047_l1065_action_invoke(&mut instance);
    c1048_l1066_action_invoke(&mut instance);
    c1049_l1067_action_invoke(&mut instance);
    c1050_l1068_action_invoke(&mut instance);
    c1051_l1069_action_invoke(&mut instance);
    c1052_l1070_action_invoke(&mut instance);
    c1053_l1071_action_invoke(&mut instance);
    c1054_l1072_action_invoke(&mut instance);
    c1055_l1073_action_invoke(&mut instance);
    c1056_l1074_action_invoke(&mut instance);
    c1057_l1075_action_invoke(&mut instance);
    c1058_l1076_action_invoke(&mut instance);
    c1059_l1077_action_invoke(&mut instance);
    c1060_l1078_action_invoke(&mut instance);
    c1061_l1079_action_invoke(&mut instance);
    c1062_l1080_action_invoke(&mut instance);
    c1063_l1081_action_invoke(&mut instance);
    c1064_l1082_action_invoke(&mut instance);
    c1065_l1083_action_invoke(&mut instance);
    c1066_l1084_action_invoke(&mut instance);
    c1067_l1085_action_invoke(&mut instance);
    c1068_l1086_action_invoke(&mut instance);
    c1069_l1087_action_invoke(&mut instance);
    c1070_l1088_action_invoke(&mut instance);
    c1071_l1089_action_invoke(&mut instance);
    c1072_l1090_action_invoke(&mut instance);
    c1073_l1091_assert_return_canonical_nan(&mut instance);
    c1074_l1092_assert_return_arithmetic_nan(&mut instance);
    c1075_l1093_assert_return_canonical_nan(&mut instance);
    c1076_l1094_assert_return_arithmetic_nan(&mut instance);
    c1077_l1095_assert_return_canonical_nan(&mut instance);
    c1078_l1096_assert_return_arithmetic_nan(&mut instance);
    c1079_l1097_assert_return_canonical_nan(&mut instance);
    c1080_l1098_assert_return_arithmetic_nan(&mut instance);
    c1081_l1099_assert_return_canonical_nan(&mut instance);
    c1082_l1100_assert_return_canonical_nan(&mut instance);
    c1083_l1101_assert_return_canonical_nan(&mut instance);
    c1084_l1102_assert_return_canonical_nan(&mut instance);
    c1085_l1103_action_invoke(&mut instance);
    c1086_l1104_action_invoke(&mut instance);
    c1087_l1105_action_invoke(&mut instance);
    c1088_l1106_action_invoke(&mut instance);
    c1089_l1107_action_invoke(&mut instance);
    c1090_l1108_action_invoke(&mut instance);
    c1091_l1109_action_invoke(&mut instance);
    c1092_l1110_action_invoke(&mut instance);
    c1093_l1111_action_invoke(&mut instance);
    c1094_l1112_action_invoke(&mut instance);
    c1095_l1113_action_invoke(&mut instance);
    c1096_l1114_action_invoke(&mut instance);
    c1097_l1115_action_invoke(&mut instance);
    c1098_l1116_action_invoke(&mut instance);
    c1099_l1117_action_invoke(&mut instance);
    c1100_l1118_action_invoke(&mut instance);
    c1101_l1119_action_invoke(&mut instance);
    c1102_l1120_action_invoke(&mut instance);
    c1103_l1121_action_invoke(&mut instance);
    c1104_l1122_action_invoke(&mut instance);
    c1105_l1123_action_invoke(&mut instance);
    c1106_l1124_action_invoke(&mut instance);
    c1107_l1125_action_invoke(&mut instance);
    c1108_l1126_action_invoke(&mut instance);
    c1109_l1127_action_invoke(&mut instance);
    c1110_l1128_action_invoke(&mut instance);
    c1111_l1129_action_invoke(&mut instance);
    c1112_l1130_action_invoke(&mut instance);
    c1113_l1131_assert_return_canonical_nan(&mut instance);
    c1114_l1132_assert_return_arithmetic_nan(&mut instance);
    c1115_l1133_assert_return_canonical_nan(&mut instance);
    c1116_l1134_assert_return_arithmetic_nan(&mut instance);
    c1117_l1135_assert_return_canonical_nan(&mut instance);
    c1118_l1136_assert_return_arithmetic_nan(&mut instance);
    c1119_l1137_assert_return_canonical_nan(&mut instance);
    c1120_l1138_assert_return_arithmetic_nan(&mut instance);
    c1121_l1139_assert_return_canonical_nan(&mut instance);
    c1122_l1140_assert_return_arithmetic_nan(&mut instance);
    c1123_l1141_assert_return_canonical_nan(&mut instance);
    c1124_l1142_assert_return_arithmetic_nan(&mut instance);
    c1125_l1143_assert_return_canonical_nan(&mut instance);
    c1126_l1144_assert_return_arithmetic_nan(&mut instance);
    c1127_l1145_assert_return_canonical_nan(&mut instance);
    c1128_l1146_assert_return_arithmetic_nan(&mut instance);
    c1129_l1147_assert_return_canonical_nan(&mut instance);
    c1130_l1148_assert_return_arithmetic_nan(&mut instance);
    c1131_l1149_assert_return_canonical_nan(&mut instance);
    c1132_l1150_assert_return_arithmetic_nan(&mut instance);
    c1133_l1151_assert_return_canonical_nan(&mut instance);
    c1134_l1152_assert_return_arithmetic_nan(&mut instance);
    c1135_l1153_assert_return_canonical_nan(&mut instance);
    c1136_l1154_assert_return_arithmetic_nan(&mut instance);
    c1137_l1155_assert_return_canonical_nan(&mut instance);
    c1138_l1156_assert_return_arithmetic_nan(&mut instance);
    c1139_l1157_assert_return_canonical_nan(&mut instance);
    c1140_l1158_assert_return_arithmetic_nan(&mut instance);
    c1141_l1159_assert_return_canonical_nan(&mut instance);
    c1142_l1160_assert_return_arithmetic_nan(&mut instance);
    c1143_l1161_assert_return_canonical_nan(&mut instance);
    c1144_l1162_assert_return_arithmetic_nan(&mut instance);
    c1145_l1163_assert_return_canonical_nan(&mut instance);
    c1146_l1164_assert_return_arithmetic_nan(&mut instance);
    c1147_l1165_assert_return_canonical_nan(&mut instance);
    c1148_l1166_assert_return_arithmetic_nan(&mut instance);
    c1149_l1167_assert_return_canonical_nan(&mut instance);
    c1150_l1168_assert_return_arithmetic_nan(&mut instance);
    c1151_l1169_assert_return_canonical_nan(&mut instance);
    c1152_l1170_assert_return_arithmetic_nan(&mut instance);
    c1153_l1171_assert_return_canonical_nan(&mut instance);
    c1154_l1172_assert_return_arithmetic_nan(&mut instance);
    c1155_l1173_assert_return_canonical_nan(&mut instance);
    c1156_l1174_assert_return_arithmetic_nan(&mut instance);
    c1157_l1175_assert_return_canonical_nan(&mut instance);
    c1158_l1176_assert_return_arithmetic_nan(&mut instance);
    c1159_l1177_assert_return_canonical_nan(&mut instance);
    c1160_l1178_assert_return_arithmetic_nan(&mut instance);
    c1161_l1179_assert_return_canonical_nan(&mut instance);
    c1162_l1180_assert_return_arithmetic_nan(&mut instance);
    c1163_l1181_assert_return_canonical_nan(&mut instance);
    c1164_l1182_assert_return_arithmetic_nan(&mut instance);
    c1165_l1183_assert_return_canonical_nan(&mut instance);
    c1166_l1184_assert_return_arithmetic_nan(&mut instance);
    c1167_l1185_assert_return_canonical_nan(&mut instance);
    c1168_l1186_assert_return_arithmetic_nan(&mut instance);
    c1169_l1187_assert_return_canonical_nan(&mut instance);
    c1170_l1188_assert_return_arithmetic_nan(&mut instance);
    c1171_l1189_assert_return_canonical_nan(&mut instance);
    c1172_l1190_assert_return_arithmetic_nan(&mut instance);
    c1173_l1191_assert_return_canonical_nan(&mut instance);
    c1174_l1192_assert_return_arithmetic_nan(&mut instance);
    c1175_l1193_assert_return_canonical_nan(&mut instance);
    c1176_l1194_assert_return_arithmetic_nan(&mut instance);
    c1177_l1195_assert_return_canonical_nan(&mut instance);
    c1178_l1196_assert_return_arithmetic_nan(&mut instance);
    c1179_l1197_assert_return_canonical_nan(&mut instance);
    c1180_l1198_assert_return_arithmetic_nan(&mut instance);
    c1181_l1199_assert_return_canonical_nan(&mut instance);
    c1182_l1200_assert_return_arithmetic_nan(&mut instance);
    c1183_l1201_assert_return_canonical_nan(&mut instance);
    c1184_l1202_assert_return_arithmetic_nan(&mut instance);
    c1185_l1203_assert_return_canonical_nan(&mut instance);
    c1186_l1204_assert_return_arithmetic_nan(&mut instance);
    c1187_l1205_assert_return_arithmetic_nan(&mut instance);
    c1188_l1206_assert_return_arithmetic_nan(&mut instance);
    c1189_l1207_assert_return_canonical_nan(&mut instance);
    c1190_l1208_assert_return_arithmetic_nan(&mut instance);
    c1191_l1209_assert_return_arithmetic_nan(&mut instance);
    c1192_l1210_assert_return_arithmetic_nan(&mut instance);
    c1193_l1211_assert_return_canonical_nan(&mut instance);
    c1194_l1212_assert_return_arithmetic_nan(&mut instance);
    c1195_l1213_assert_return_arithmetic_nan(&mut instance);
    c1196_l1214_assert_return_arithmetic_nan(&mut instance);
    c1197_l1215_assert_return_canonical_nan(&mut instance);
    c1198_l1216_assert_return_arithmetic_nan(&mut instance);
    c1199_l1217_assert_return_arithmetic_nan(&mut instance);
    c1200_l1218_assert_return_arithmetic_nan(&mut instance);
    c1201_l1219_assert_return_canonical_nan(&mut instance);
    c1202_l1220_assert_return_canonical_nan(&mut instance);
    c1203_l1221_assert_return_canonical_nan(&mut instance);
    c1204_l1222_assert_return_canonical_nan(&mut instance);
    c1205_l1223_action_invoke(&mut instance);
    c1206_l1224_action_invoke(&mut instance);
    c1207_l1225_action_invoke(&mut instance);
    c1208_l1226_action_invoke(&mut instance);
    c1209_l1227_action_invoke(&mut instance);
    c1210_l1228_action_invoke(&mut instance);
    c1211_l1229_action_invoke(&mut instance);
    c1212_l1230_action_invoke(&mut instance);
    c1213_l1231_action_invoke(&mut instance);
    c1214_l1232_action_invoke(&mut instance);
    c1215_l1233_action_invoke(&mut instance);
    c1216_l1234_action_invoke(&mut instance);
    c1217_l1235_action_invoke(&mut instance);
    c1218_l1236_action_invoke(&mut instance);
    c1219_l1237_action_invoke(&mut instance);
    c1220_l1238_action_invoke(&mut instance);
    c1221_l1239_action_invoke(&mut instance);
    c1222_l1240_action_invoke(&mut instance);
    c1223_l1241_action_invoke(&mut instance);
    c1224_l1242_action_invoke(&mut instance);
    c1225_l1243_action_invoke(&mut instance);
    c1226_l1244_action_invoke(&mut instance);
    c1227_l1245_action_invoke(&mut instance);
    c1228_l1246_action_invoke(&mut instance);
    c1229_l1247_action_invoke(&mut instance);
    c1230_l1248_action_invoke(&mut instance);
    c1231_l1249_action_invoke(&mut instance);
    c1232_l1250_action_invoke(&mut instance);
    c1233_l1251_assert_return_canonical_nan(&mut instance);
    c1234_l1252_assert_return_arithmetic_nan(&mut instance);
    c1235_l1253_assert_return_canonical_nan(&mut instance);
    c1236_l1254_assert_return_arithmetic_nan(&mut instance);
    c1237_l1255_assert_return_canonical_nan(&mut instance);
    c1238_l1256_assert_return_arithmetic_nan(&mut instance);
    c1239_l1257_assert_return_canonical_nan(&mut instance);
    c1240_l1258_assert_return_arithmetic_nan(&mut instance);
    c1241_l1259_action_invoke(&mut instance);
    c1242_l1260_action_invoke(&mut instance);
    c1243_l1261_action_invoke(&mut instance);
    c1244_l1262_action_invoke(&mut instance);
    c1245_l1263_action_invoke(&mut instance);
    c1246_l1264_action_invoke(&mut instance);
    c1247_l1265_action_invoke(&mut instance);
    c1248_l1266_action_invoke(&mut instance);
    c1249_l1267_action_invoke(&mut instance);
    c1250_l1268_action_invoke(&mut instance);
    c1251_l1269_action_invoke(&mut instance);
    c1252_l1270_action_invoke(&mut instance);
    c1253_l1271_action_invoke(&mut instance);
    c1254_l1272_action_invoke(&mut instance);
    c1255_l1273_action_invoke(&mut instance);
    c1256_l1274_action_invoke(&mut instance);
    c1257_l1275_action_invoke(&mut instance);
    c1258_l1276_action_invoke(&mut instance);
    c1259_l1277_action_invoke(&mut instance);
    c1260_l1278_action_invoke(&mut instance);
    c1261_l1279_action_invoke(&mut instance);
    c1262_l1280_action_invoke(&mut instance);
    c1263_l1281_action_invoke(&mut instance);
    c1264_l1282_action_invoke(&mut instance);
    c1265_l1283_action_invoke(&mut instance);
    c1266_l1284_action_invoke(&mut instance);
    c1267_l1285_action_invoke(&mut instance);
    c1268_l1286_action_invoke(&mut instance);
    c1269_l1287_action_invoke(&mut instance);
    c1270_l1288_action_invoke(&mut instance);
    c1271_l1289_action_invoke(&mut instance);
    c1272_l1290_action_invoke(&mut instance);
    c1273_l1291_assert_return_canonical_nan(&mut instance);
    c1274_l1292_assert_return_arithmetic_nan(&mut instance);
    c1275_l1293_assert_return_canonical_nan(&mut instance);
    c1276_l1294_assert_return_arithmetic_nan(&mut instance);
    c1277_l1295_assert_return_canonical_nan(&mut instance);
    c1278_l1296_assert_return_arithmetic_nan(&mut instance);
    c1279_l1297_assert_return_canonical_nan(&mut instance);
    c1280_l1298_assert_return_arithmetic_nan(&mut instance);
    c1281_l1299_action_invoke(&mut instance);
    c1282_l1300_action_invoke(&mut instance);
    c1283_l1301_action_invoke(&mut instance);
    c1284_l1302_action_invoke(&mut instance);
    c1285_l1303_action_invoke(&mut instance);
    c1286_l1304_action_invoke(&mut instance);
    c1287_l1305_action_invoke(&mut instance);
    c1288_l1306_action_invoke(&mut instance);
    c1289_l1307_action_invoke(&mut instance);
    c1290_l1308_action_invoke(&mut instance);
    c1291_l1309_action_invoke(&mut instance);
    c1292_l1310_action_invoke(&mut instance);
    c1293_l1311_action_invoke(&mut instance);
    c1294_l1312_action_invoke(&mut instance);
    c1295_l1313_action_invoke(&mut instance);
    c1296_l1314_action_invoke(&mut instance);
    c1297_l1315_action_invoke(&mut instance);
    c1298_l1316_action_invoke(&mut instance);
    c1299_l1317_action_invoke(&mut instance);
    c1300_l1318_action_invoke(&mut instance);
    c1301_l1319_action_invoke(&mut instance);
    c1302_l1320_action_invoke(&mut instance);
    c1303_l1321_action_invoke(&mut instance);
    c1304_l1322_action_invoke(&mut instance);
    c1305_l1323_action_invoke(&mut instance);
    c1306_l1324_action_invoke(&mut instance);
    c1307_l1325_action_invoke(&mut instance);
    c1308_l1326_action_invoke(&mut instance);
    c1309_l1327_action_invoke(&mut instance);
    c1310_l1328_action_invoke(&mut instance);
    c1311_l1329_action_invoke(&mut instance);
    c1312_l1330_action_invoke(&mut instance);
    c1313_l1331_assert_return_canonical_nan(&mut instance);
    c1314_l1332_assert_return_arithmetic_nan(&mut instance);
    c1315_l1333_assert_return_canonical_nan(&mut instance);
    c1316_l1334_assert_return_arithmetic_nan(&mut instance);
    c1317_l1335_assert_return_canonical_nan(&mut instance);
    c1318_l1336_assert_return_arithmetic_nan(&mut instance);
    c1319_l1337_assert_return_canonical_nan(&mut instance);
    c1320_l1338_assert_return_arithmetic_nan(&mut instance);
    c1321_l1339_action_invoke(&mut instance);
    c1322_l1340_action_invoke(&mut instance);
    c1323_l1341_action_invoke(&mut instance);
    c1324_l1342_action_invoke(&mut instance);
    c1325_l1343_action_invoke(&mut instance);
    c1326_l1344_action_invoke(&mut instance);
    c1327_l1345_action_invoke(&mut instance);
    c1328_l1346_action_invoke(&mut instance);
    c1329_l1347_action_invoke(&mut instance);
    c1330_l1348_action_invoke(&mut instance);
    c1331_l1349_action_invoke(&mut instance);
    c1332_l1350_action_invoke(&mut instance);
    c1333_l1351_action_invoke(&mut instance);
    c1334_l1352_action_invoke(&mut instance);
    c1335_l1353_action_invoke(&mut instance);
    c1336_l1354_action_invoke(&mut instance);
    c1337_l1355_action_invoke(&mut instance);
    c1338_l1356_action_invoke(&mut instance);
    c1339_l1357_action_invoke(&mut instance);
    c1340_l1358_action_invoke(&mut instance);
    c1341_l1359_action_invoke(&mut instance);
    c1342_l1360_action_invoke(&mut instance);
    c1343_l1361_action_invoke(&mut instance);
    c1344_l1362_action_invoke(&mut instance);
    c1345_l1363_action_invoke(&mut instance);
    c1346_l1364_action_invoke(&mut instance);
    c1347_l1365_action_invoke(&mut instance);
    c1348_l1366_action_invoke(&mut instance);
    c1349_l1367_action_invoke(&mut instance);
    c1350_l1368_action_invoke(&mut instance);
    c1351_l1369_action_invoke(&mut instance);
    c1352_l1370_action_invoke(&mut instance);
    c1353_l1371_assert_return_canonical_nan(&mut instance);
    c1354_l1372_assert_return_arithmetic_nan(&mut instance);
    c1355_l1373_assert_return_canonical_nan(&mut instance);
    c1356_l1374_assert_return_arithmetic_nan(&mut instance);
    c1357_l1375_assert_return_canonical_nan(&mut instance);
    c1358_l1376_assert_return_arithmetic_nan(&mut instance);
    c1359_l1377_assert_return_canonical_nan(&mut instance);
    c1360_l1378_assert_return_arithmetic_nan(&mut instance);
    c1361_l1379_action_invoke(&mut instance);
    c1362_l1380_action_invoke(&mut instance);
    c1363_l1381_action_invoke(&mut instance);
    c1364_l1382_action_invoke(&mut instance);
    c1365_l1383_action_invoke(&mut instance);
    c1366_l1384_action_invoke(&mut instance);
    c1367_l1385_action_invoke(&mut instance);
    c1368_l1386_action_invoke(&mut instance);
    c1369_l1387_action_invoke(&mut instance);
    c1370_l1388_action_invoke(&mut instance);
    c1371_l1389_action_invoke(&mut instance);
    c1372_l1390_action_invoke(&mut instance);
    c1373_l1391_action_invoke(&mut instance);
    c1374_l1392_action_invoke(&mut instance);
    c1375_l1393_action_invoke(&mut instance);
    c1376_l1394_action_invoke(&mut instance);
    c1377_l1395_action_invoke(&mut instance);
    c1378_l1396_action_invoke(&mut instance);
    c1379_l1397_action_invoke(&mut instance);
    c1380_l1398_action_invoke(&mut instance);
    c1381_l1399_action_invoke(&mut instance);
    c1382_l1400_action_invoke(&mut instance);
    c1383_l1401_action_invoke(&mut instance);
    c1384_l1402_action_invoke(&mut instance);
    c1385_l1403_action_invoke(&mut instance);
    c1386_l1404_action_invoke(&mut instance);
    c1387_l1405_action_invoke(&mut instance);
    c1388_l1406_action_invoke(&mut instance);
    c1389_l1407_action_invoke(&mut instance);
    c1390_l1408_action_invoke(&mut instance);
    c1391_l1409_action_invoke(&mut instance);
    c1392_l1410_action_invoke(&mut instance);
    c1393_l1411_assert_return_canonical_nan(&mut instance);
    c1394_l1412_assert_return_arithmetic_nan(&mut instance);
    c1395_l1413_assert_return_canonical_nan(&mut instance);
    c1396_l1414_assert_return_arithmetic_nan(&mut instance);
    c1397_l1415_assert_return_canonical_nan(&mut instance);
    c1398_l1416_assert_return_arithmetic_nan(&mut instance);
    c1399_l1417_assert_return_canonical_nan(&mut instance);
    c1400_l1418_assert_return_arithmetic_nan(&mut instance);
    c1401_l1419_action_invoke(&mut instance);
    c1402_l1420_action_invoke(&mut instance);
    c1403_l1421_action_invoke(&mut instance);
    c1404_l1422_action_invoke(&mut instance);
    c1405_l1423_action_invoke(&mut instance);
    c1406_l1424_action_invoke(&mut instance);
    c1407_l1425_action_invoke(&mut instance);
    c1408_l1426_action_invoke(&mut instance);
    c1409_l1427_action_invoke(&mut instance);
    c1410_l1428_action_invoke(&mut instance);
    c1411_l1429_action_invoke(&mut instance);
    c1412_l1430_action_invoke(&mut instance);
    c1413_l1431_action_invoke(&mut instance);
    c1414_l1432_action_invoke(&mut instance);
    c1415_l1433_action_invoke(&mut instance);
    c1416_l1434_action_invoke(&mut instance);
    c1417_l1435_action_invoke(&mut instance);
    c1418_l1436_action_invoke(&mut instance);
    c1419_l1437_action_invoke(&mut instance);
    c1420_l1438_action_invoke(&mut instance);
    c1421_l1439_action_invoke(&mut instance);
    c1422_l1440_action_invoke(&mut instance);
    c1423_l1441_action_invoke(&mut instance);
    c1424_l1442_action_invoke(&mut instance);
    c1425_l1443_action_invoke(&mut instance);
    c1426_l1444_action_invoke(&mut instance);
    c1427_l1445_action_invoke(&mut instance);
    c1428_l1446_action_invoke(&mut instance);
    c1429_l1447_action_invoke(&mut instance);
    c1430_l1448_action_invoke(&mut instance);
    c1431_l1449_action_invoke(&mut instance);
    c1432_l1450_action_invoke(&mut instance);
    c1433_l1451_assert_return_canonical_nan(&mut instance);
    c1434_l1452_assert_return_arithmetic_nan(&mut instance);
    c1435_l1453_assert_return_canonical_nan(&mut instance);
    c1436_l1454_assert_return_arithmetic_nan(&mut instance);
    c1437_l1455_assert_return_canonical_nan(&mut instance);
    c1438_l1456_assert_return_arithmetic_nan(&mut instance);
    c1439_l1457_assert_return_canonical_nan(&mut instance);
    c1440_l1458_assert_return_arithmetic_nan(&mut instance);
    c1441_l1459_action_invoke(&mut instance);
    c1442_l1460_action_invoke(&mut instance);
    c1443_l1461_action_invoke(&mut instance);
    c1444_l1462_action_invoke(&mut instance);
    c1445_l1463_action_invoke(&mut instance);
    c1446_l1464_action_invoke(&mut instance);
    c1447_l1465_action_invoke(&mut instance);
    c1448_l1466_action_invoke(&mut instance);
    c1449_l1467_action_invoke(&mut instance);
    c1450_l1468_action_invoke(&mut instance);
    c1451_l1469_action_invoke(&mut instance);
    c1452_l1470_action_invoke(&mut instance);
    c1453_l1471_action_invoke(&mut instance);
    c1454_l1472_action_invoke(&mut instance);
    c1455_l1473_action_invoke(&mut instance);
    c1456_l1474_action_invoke(&mut instance);
    c1457_l1475_action_invoke(&mut instance);
    c1458_l1476_action_invoke(&mut instance);
    c1459_l1477_action_invoke(&mut instance);
    c1460_l1478_action_invoke(&mut instance);
    c1461_l1479_action_invoke(&mut instance);
    c1462_l1480_action_invoke(&mut instance);
    c1463_l1481_action_invoke(&mut instance);
    c1464_l1482_action_invoke(&mut instance);
    c1465_l1483_action_invoke(&mut instance);
    c1466_l1484_action_invoke(&mut instance);
    c1467_l1485_action_invoke(&mut instance);
    c1468_l1486_action_invoke(&mut instance);
    c1469_l1487_action_invoke(&mut instance);
    c1470_l1488_action_invoke(&mut instance);
    c1471_l1489_action_invoke(&mut instance);
    c1472_l1490_action_invoke(&mut instance);
    c1473_l1491_assert_return_canonical_nan(&mut instance);
    c1474_l1492_assert_return_arithmetic_nan(&mut instance);
    c1475_l1493_assert_return_canonical_nan(&mut instance);
    c1476_l1494_assert_return_arithmetic_nan(&mut instance);
    c1477_l1495_assert_return_canonical_nan(&mut instance);
    c1478_l1496_assert_return_arithmetic_nan(&mut instance);
    c1479_l1497_assert_return_canonical_nan(&mut instance);
    c1480_l1498_assert_return_arithmetic_nan(&mut instance);
    c1481_l1499_action_invoke(&mut instance);
    c1482_l1500_action_invoke(&mut instance);
    c1483_l1501_action_invoke(&mut instance);
    c1484_l1502_action_invoke(&mut instance);
    c1485_l1503_action_invoke(&mut instance);
    c1486_l1504_action_invoke(&mut instance);
    c1487_l1505_action_invoke(&mut instance);
    c1488_l1506_action_invoke(&mut instance);
    c1489_l1507_action_invoke(&mut instance);
    c1490_l1508_action_invoke(&mut instance);
    c1491_l1509_action_invoke(&mut instance);
    c1492_l1510_action_invoke(&mut instance);
    c1493_l1511_action_invoke(&mut instance);
    c1494_l1512_action_invoke(&mut instance);
    c1495_l1513_action_invoke(&mut instance);
    c1496_l1514_action_invoke(&mut instance);
    c1497_l1515_action_invoke(&mut instance);
    c1498_l1516_action_invoke(&mut instance);
    c1499_l1517_action_invoke(&mut instance);
    c1500_l1518_action_invoke(&mut instance);
    c1501_l1519_action_invoke(&mut instance);
    c1502_l1520_action_invoke(&mut instance);
    c1503_l1521_action_invoke(&mut instance);
    c1504_l1522_action_invoke(&mut instance);
    c1505_l1523_action_invoke(&mut instance);
    c1506_l1524_action_invoke(&mut instance);
    c1507_l1525_action_invoke(&mut instance);
    c1508_l1526_action_invoke(&mut instance);
    c1509_l1527_assert_return_canonical_nan(&mut instance);
    c1510_l1528_assert_return_canonical_nan(&mut instance);
    c1511_l1529_assert_return_canonical_nan(&mut instance);
    c1512_l1530_assert_return_canonical_nan(&mut instance);
    c1513_l1531_assert_return_canonical_nan(&mut instance);
    c1514_l1532_assert_return_arithmetic_nan(&mut instance);
    c1515_l1533_assert_return_canonical_nan(&mut instance);
    c1516_l1534_assert_return_arithmetic_nan(&mut instance);
    c1517_l1535_assert_return_canonical_nan(&mut instance);
    c1518_l1536_assert_return_arithmetic_nan(&mut instance);
    c1519_l1537_assert_return_canonical_nan(&mut instance);
    c1520_l1538_assert_return_arithmetic_nan(&mut instance);
    c1521_l1539_assert_return_canonical_nan(&mut instance);
    c1522_l1540_assert_return_arithmetic_nan(&mut instance);
    c1523_l1541_assert_return_canonical_nan(&mut instance);
    c1524_l1542_assert_return_arithmetic_nan(&mut instance);
    c1525_l1543_assert_return_canonical_nan(&mut instance);
    c1526_l1544_assert_return_arithmetic_nan(&mut instance);
    c1527_l1545_assert_return_canonical_nan(&mut instance);
    c1528_l1546_assert_return_arithmetic_nan(&mut instance);
    c1529_l1547_assert_return_canonical_nan(&mut instance);
    c1530_l1548_assert_return_arithmetic_nan(&mut instance);
    c1531_l1549_assert_return_canonical_nan(&mut instance);
    c1532_l1550_assert_return_arithmetic_nan(&mut instance);
    c1533_l1551_assert_return_canonical_nan(&mut instance);
    c1534_l1552_assert_return_arithmetic_nan(&mut instance);
    c1535_l1553_assert_return_canonical_nan(&mut instance);
    c1536_l1554_assert_return_arithmetic_nan(&mut instance);
    c1537_l1555_assert_return_canonical_nan(&mut instance);
    c1538_l1556_assert_return_arithmetic_nan(&mut instance);
    c1539_l1557_assert_return_canonical_nan(&mut instance);
    c1540_l1558_assert_return_arithmetic_nan(&mut instance);
    c1541_l1559_assert_return_canonical_nan(&mut instance);
    c1542_l1560_assert_return_arithmetic_nan(&mut instance);
    c1543_l1561_assert_return_canonical_nan(&mut instance);
    c1544_l1562_assert_return_arithmetic_nan(&mut instance);
    c1545_l1563_assert_return_canonical_nan(&mut instance);
    c1546_l1564_assert_return_arithmetic_nan(&mut instance);
    c1547_l1565_assert_return_canonical_nan(&mut instance);
    c1548_l1566_assert_return_arithmetic_nan(&mut instance);
    c1549_l1567_assert_return_canonical_nan(&mut instance);
    c1550_l1568_assert_return_arithmetic_nan(&mut instance);
    c1551_l1569_assert_return_canonical_nan(&mut instance);
    c1552_l1570_assert_return_arithmetic_nan(&mut instance);
    c1553_l1571_assert_return_canonical_nan(&mut instance);
    c1554_l1572_assert_return_arithmetic_nan(&mut instance);
    c1555_l1573_assert_return_canonical_nan(&mut instance);
    c1556_l1574_assert_return_arithmetic_nan(&mut instance);
    c1557_l1575_assert_return_canonical_nan(&mut instance);
    c1558_l1576_assert_return_arithmetic_nan(&mut instance);
    c1559_l1577_assert_return_canonical_nan(&mut instance);
    c1560_l1578_assert_return_arithmetic_nan(&mut instance);
    c1561_l1579_assert_return_canonical_nan(&mut instance);
    c1562_l1580_assert_return_arithmetic_nan(&mut instance);
    c1563_l1581_assert_return_canonical_nan(&mut instance);
    c1564_l1582_assert_return_arithmetic_nan(&mut instance);
    c1565_l1583_assert_return_canonical_nan(&mut instance);
    c1566_l1584_assert_return_arithmetic_nan(&mut instance);
    c1567_l1585_assert_return_canonical_nan(&mut instance);
    c1568_l1586_assert_return_arithmetic_nan(&mut instance);
    c1569_l1587_assert_return_canonical_nan(&mut instance);
    c1570_l1588_assert_return_arithmetic_nan(&mut instance);
    c1571_l1589_assert_return_canonical_nan(&mut instance);
    c1572_l1590_assert_return_arithmetic_nan(&mut instance);
    c1573_l1591_assert_return_canonical_nan(&mut instance);
    c1574_l1592_assert_return_arithmetic_nan(&mut instance);
    c1575_l1593_assert_return_canonical_nan(&mut instance);
    c1576_l1594_assert_return_arithmetic_nan(&mut instance);
    c1577_l1595_assert_return_canonical_nan(&mut instance);
    c1578_l1596_assert_return_arithmetic_nan(&mut instance);
    c1579_l1597_assert_return_canonical_nan(&mut instance);
    c1580_l1598_assert_return_arithmetic_nan(&mut instance);
    c1581_l1599_assert_return_canonical_nan(&mut instance);
    c1582_l1600_assert_return_arithmetic_nan(&mut instance);
    c1583_l1601_assert_return_canonical_nan(&mut instance);
    c1584_l1602_assert_return_arithmetic_nan(&mut instance);
    c1585_l1603_assert_return_canonical_nan(&mut instance);
    c1586_l1604_assert_return_arithmetic_nan(&mut instance);
    c1587_l1605_assert_return_arithmetic_nan(&mut instance);
    c1588_l1606_assert_return_arithmetic_nan(&mut instance);
    c1589_l1607_assert_return_canonical_nan(&mut instance);
    c1590_l1608_assert_return_arithmetic_nan(&mut instance);
    c1591_l1609_assert_return_arithmetic_nan(&mut instance);
    c1592_l1610_assert_return_arithmetic_nan(&mut instance);
    c1593_l1611_assert_return_canonical_nan(&mut instance);
    c1594_l1612_assert_return_arithmetic_nan(&mut instance);
    c1595_l1613_assert_return_arithmetic_nan(&mut instance);
    c1596_l1614_assert_return_arithmetic_nan(&mut instance);
    c1597_l1615_assert_return_canonical_nan(&mut instance);
    c1598_l1616_assert_return_arithmetic_nan(&mut instance);
    c1599_l1617_assert_return_arithmetic_nan(&mut instance);
    c1600_l1618_assert_return_arithmetic_nan(&mut instance);
    c1601_l1619_action_invoke(&mut instance);
    c1602_l1620_action_invoke(&mut instance);
    c1603_l1621_action_invoke(&mut instance);
    c1604_l1622_action_invoke(&mut instance);
    c1605_l1623_action_invoke(&mut instance);
    c1606_l1624_action_invoke(&mut instance);
    c1607_l1625_action_invoke(&mut instance);
    c1608_l1626_action_invoke(&mut instance);
    c1609_l1627_action_invoke(&mut instance);
    c1610_l1628_action_invoke(&mut instance);
    c1611_l1629_action_invoke(&mut instance);
    c1612_l1630_action_invoke(&mut instance);
    c1613_l1631_action_invoke(&mut instance);
    c1614_l1632_action_invoke(&mut instance);
    c1615_l1633_action_invoke(&mut instance);
    c1616_l1634_action_invoke(&mut instance);
    c1617_l1635_action_invoke(&mut instance);
    c1618_l1636_action_invoke(&mut instance);
    c1619_l1637_action_invoke(&mut instance);
    c1620_l1638_action_invoke(&mut instance);
    c1621_l1639_action_invoke(&mut instance);
    c1622_l1640_action_invoke(&mut instance);
    c1623_l1641_action_invoke(&mut instance);
    c1624_l1642_action_invoke(&mut instance);
    c1625_l1643_action_invoke(&mut instance);
    c1626_l1644_action_invoke(&mut instance);
    c1627_l1645_action_invoke(&mut instance);
    c1628_l1646_action_invoke(&mut instance);
    c1629_l1647_action_invoke(&mut instance);
    c1630_l1648_action_invoke(&mut instance);
    c1631_l1649_action_invoke(&mut instance);
    c1632_l1650_action_invoke(&mut instance);
    c1633_l1651_assert_return_canonical_nan(&mut instance);
    c1634_l1652_assert_return_arithmetic_nan(&mut instance);
    c1635_l1653_assert_return_canonical_nan(&mut instance);
    c1636_l1654_assert_return_arithmetic_nan(&mut instance);
    c1637_l1655_assert_return_canonical_nan(&mut instance);
    c1638_l1656_assert_return_arithmetic_nan(&mut instance);
    c1639_l1657_assert_return_canonical_nan(&mut instance);
    c1640_l1658_assert_return_arithmetic_nan(&mut instance);
    c1641_l1659_action_invoke(&mut instance);
    c1642_l1660_action_invoke(&mut instance);
    c1643_l1661_action_invoke(&mut instance);
    c1644_l1662_action_invoke(&mut instance);
    c1645_l1663_action_invoke(&mut instance);
    c1646_l1664_action_invoke(&mut instance);
    c1647_l1665_action_invoke(&mut instance);
    c1648_l1666_action_invoke(&mut instance);
    c1649_l1667_action_invoke(&mut instance);
    c1650_l1668_action_invoke(&mut instance);
    c1651_l1669_action_invoke(&mut instance);
    c1652_l1670_action_invoke(&mut instance);
    c1653_l1671_action_invoke(&mut instance);
    c1654_l1672_action_invoke(&mut instance);
    c1655_l1673_action_invoke(&mut instance);
    c1656_l1674_action_invoke(&mut instance);
    c1657_l1675_action_invoke(&mut instance);
    c1658_l1676_action_invoke(&mut instance);
    c1659_l1677_action_invoke(&mut instance);
    c1660_l1678_action_invoke(&mut instance);
    c1661_l1679_action_invoke(&mut instance);
    c1662_l1680_action_invoke(&mut instance);
    c1663_l1681_action_invoke(&mut instance);
    c1664_l1682_action_invoke(&mut instance);
    c1665_l1683_action_invoke(&mut instance);
    c1666_l1684_action_invoke(&mut instance);
    c1667_l1685_action_invoke(&mut instance);
    c1668_l1686_action_invoke(&mut instance);
    c1669_l1687_action_invoke(&mut instance);
    c1670_l1688_action_invoke(&mut instance);
    c1671_l1689_action_invoke(&mut instance);
    c1672_l1690_action_invoke(&mut instance);
    c1673_l1691_assert_return_canonical_nan(&mut instance);
    c1674_l1692_assert_return_arithmetic_nan(&mut instance);
    c1675_l1693_assert_return_canonical_nan(&mut instance);
    c1676_l1694_assert_return_arithmetic_nan(&mut instance);
    c1677_l1695_assert_return_canonical_nan(&mut instance);
    c1678_l1696_assert_return_arithmetic_nan(&mut instance);
    c1679_l1697_assert_return_canonical_nan(&mut instance);
    c1680_l1698_assert_return_arithmetic_nan(&mut instance);
    c1681_l1699_action_invoke(&mut instance);
    c1682_l1700_action_invoke(&mut instance);
    c1683_l1701_action_invoke(&mut instance);
    c1684_l1702_action_invoke(&mut instance);
    c1685_l1703_action_invoke(&mut instance);
    c1686_l1704_action_invoke(&mut instance);
    c1687_l1705_action_invoke(&mut instance);
    c1688_l1706_action_invoke(&mut instance);
    c1689_l1707_action_invoke(&mut instance);
    c1690_l1708_action_invoke(&mut instance);
    c1691_l1709_action_invoke(&mut instance);
    c1692_l1710_action_invoke(&mut instance);
    c1693_l1711_action_invoke(&mut instance);
    c1694_l1712_action_invoke(&mut instance);
    c1695_l1713_action_invoke(&mut instance);
    c1696_l1714_action_invoke(&mut instance);
    c1697_l1715_action_invoke(&mut instance);
    c1698_l1716_action_invoke(&mut instance);
    c1699_l1717_action_invoke(&mut instance);
    c1700_l1718_action_invoke(&mut instance);
    c1701_l1719_action_invoke(&mut instance);
    c1702_l1720_action_invoke(&mut instance);
    c1703_l1721_action_invoke(&mut instance);
    c1704_l1722_action_invoke(&mut instance);
    c1705_l1723_action_invoke(&mut instance);
    c1706_l1724_action_invoke(&mut instance);
    c1707_l1725_action_invoke(&mut instance);
    c1708_l1726_action_invoke(&mut instance);
    c1709_l1727_action_invoke(&mut instance);
    c1710_l1728_action_invoke(&mut instance);
    c1711_l1729_action_invoke(&mut instance);
    c1712_l1730_action_invoke(&mut instance);
    c1713_l1731_assert_return_canonical_nan(&mut instance);
    c1714_l1732_assert_return_arithmetic_nan(&mut instance);
    c1715_l1733_assert_return_canonical_nan(&mut instance);
    c1716_l1734_assert_return_arithmetic_nan(&mut instance);
    c1717_l1735_assert_return_canonical_nan(&mut instance);
    c1718_l1736_assert_return_arithmetic_nan(&mut instance);
    c1719_l1737_assert_return_canonical_nan(&mut instance);
    c1720_l1738_assert_return_arithmetic_nan(&mut instance);
    c1721_l1739_action_invoke(&mut instance);
    c1722_l1740_action_invoke(&mut instance);
    c1723_l1741_action_invoke(&mut instance);
    c1724_l1742_action_invoke(&mut instance);
    c1725_l1743_action_invoke(&mut instance);
    c1726_l1744_action_invoke(&mut instance);
    c1727_l1745_action_invoke(&mut instance);
    c1728_l1746_action_invoke(&mut instance);
    c1729_l1747_action_invoke(&mut instance);
    c1730_l1748_action_invoke(&mut instance);
    c1731_l1749_action_invoke(&mut instance);
    c1732_l1750_action_invoke(&mut instance);
    c1733_l1751_action_invoke(&mut instance);
    c1734_l1752_action_invoke(&mut instance);
    c1735_l1753_action_invoke(&mut instance);
    c1736_l1754_action_invoke(&mut instance);
    c1737_l1755_action_invoke(&mut instance);
    c1738_l1756_action_invoke(&mut instance);
    c1739_l1757_action_invoke(&mut instance);
    c1740_l1758_action_invoke(&mut instance);
    c1741_l1759_action_invoke(&mut instance);
    c1742_l1760_action_invoke(&mut instance);
    c1743_l1761_action_invoke(&mut instance);
    c1744_l1762_action_invoke(&mut instance);
    c1745_l1763_action_invoke(&mut instance);
    c1746_l1764_action_invoke(&mut instance);
    c1747_l1765_action_invoke(&mut instance);
    c1748_l1766_action_invoke(&mut instance);
    c1749_l1767_action_invoke(&mut instance);
    c1750_l1768_action_invoke(&mut instance);
    c1751_l1769_action_invoke(&mut instance);
    c1752_l1770_action_invoke(&mut instance);
    c1753_l1771_assert_return_canonical_nan(&mut instance);
    c1754_l1772_assert_return_arithmetic_nan(&mut instance);
    c1755_l1773_assert_return_canonical_nan(&mut instance);
    c1756_l1774_assert_return_arithmetic_nan(&mut instance);
    c1757_l1775_assert_return_canonical_nan(&mut instance);
    c1758_l1776_assert_return_arithmetic_nan(&mut instance);
    c1759_l1777_assert_return_canonical_nan(&mut instance);
    c1760_l1778_assert_return_arithmetic_nan(&mut instance);
    c1761_l1779_action_invoke(&mut instance);
    c1762_l1780_action_invoke(&mut instance);
    c1763_l1781_action_invoke(&mut instance);
    c1764_l1782_action_invoke(&mut instance);
    c1765_l1783_action_invoke(&mut instance);
    c1766_l1784_action_invoke(&mut instance);
    c1767_l1785_action_invoke(&mut instance);
    c1768_l1786_action_invoke(&mut instance);
    c1769_l1787_action_invoke(&mut instance);
    c1770_l1788_action_invoke(&mut instance);
    c1771_l1789_action_invoke(&mut instance);
    c1772_l1790_action_invoke(&mut instance);
    c1773_l1791_action_invoke(&mut instance);
    c1774_l1792_action_invoke(&mut instance);
    c1775_l1793_action_invoke(&mut instance);
    c1776_l1794_action_invoke(&mut instance);
    c1777_l1795_action_invoke(&mut instance);
    c1778_l1796_action_invoke(&mut instance);
    c1779_l1797_action_invoke(&mut instance);
    c1780_l1798_action_invoke(&mut instance);
    c1781_l1799_action_invoke(&mut instance);
    c1782_l1800_action_invoke(&mut instance);
    c1783_l1801_action_invoke(&mut instance);
    c1784_l1802_action_invoke(&mut instance);
    c1785_l1803_action_invoke(&mut instance);
    c1786_l1804_action_invoke(&mut instance);
    c1787_l1805_action_invoke(&mut instance);
    c1788_l1806_action_invoke(&mut instance);
    c1789_l1807_action_invoke(&mut instance);
    c1790_l1808_action_invoke(&mut instance);
    c1791_l1809_action_invoke(&mut instance);
    c1792_l1810_action_invoke(&mut instance);
    c1793_l1811_assert_return_canonical_nan(&mut instance);
    c1794_l1812_assert_return_arithmetic_nan(&mut instance);
    c1795_l1813_assert_return_canonical_nan(&mut instance);
    c1796_l1814_assert_return_arithmetic_nan(&mut instance);
    c1797_l1815_assert_return_canonical_nan(&mut instance);
    c1798_l1816_assert_return_arithmetic_nan(&mut instance);
    c1799_l1817_assert_return_canonical_nan(&mut instance);
    c1800_l1818_assert_return_arithmetic_nan(&mut instance);
    c1801_l1819_action_invoke(&mut instance);
    c1802_l1820_action_invoke(&mut instance);
    c1803_l1821_action_invoke(&mut instance);
    c1804_l1822_action_invoke(&mut instance);
    c1805_l1823_action_invoke(&mut instance);
    c1806_l1824_action_invoke(&mut instance);
    c1807_l1825_action_invoke(&mut instance);
    c1808_l1826_action_invoke(&mut instance);
    c1809_l1827_action_invoke(&mut instance);
    c1810_l1828_action_invoke(&mut instance);
    c1811_l1829_action_invoke(&mut instance);
    c1812_l1830_action_invoke(&mut instance);
    c1813_l1831_action_invoke(&mut instance);
    c1814_l1832_action_invoke(&mut instance);
    c1815_l1833_action_invoke(&mut instance);
    c1816_l1834_action_invoke(&mut instance);
    c1817_l1835_action_invoke(&mut instance);
    c1818_l1836_action_invoke(&mut instance);
    c1819_l1837_action_invoke(&mut instance);
    c1820_l1838_action_invoke(&mut instance);
    c1821_l1839_action_invoke(&mut instance);
    c1822_l1840_action_invoke(&mut instance);
    c1823_l1841_action_invoke(&mut instance);
    c1824_l1842_action_invoke(&mut instance);
    c1825_l1843_action_invoke(&mut instance);
    c1826_l1844_action_invoke(&mut instance);
    c1827_l1845_action_invoke(&mut instance);
    c1828_l1846_action_invoke(&mut instance);
    c1829_l1847_action_invoke(&mut instance);
    c1830_l1848_action_invoke(&mut instance);
    c1831_l1849_action_invoke(&mut instance);
    c1832_l1850_action_invoke(&mut instance);
    c1833_l1851_assert_return_canonical_nan(&mut instance);
    c1834_l1852_assert_return_arithmetic_nan(&mut instance);
    c1835_l1853_assert_return_canonical_nan(&mut instance);
    c1836_l1854_assert_return_arithmetic_nan(&mut instance);
    c1837_l1855_assert_return_canonical_nan(&mut instance);
    c1838_l1856_assert_return_arithmetic_nan(&mut instance);
    c1839_l1857_assert_return_canonical_nan(&mut instance);
    c1840_l1858_assert_return_arithmetic_nan(&mut instance);
    c1841_l1859_action_invoke(&mut instance);
    c1842_l1860_action_invoke(&mut instance);
    c1843_l1861_action_invoke(&mut instance);
    c1844_l1862_action_invoke(&mut instance);
    c1845_l1863_action_invoke(&mut instance);
    c1846_l1864_action_invoke(&mut instance);
    c1847_l1865_action_invoke(&mut instance);
    c1848_l1866_action_invoke(&mut instance);
    c1849_l1867_action_invoke(&mut instance);
    c1850_l1868_action_invoke(&mut instance);
    c1851_l1869_action_invoke(&mut instance);
    c1852_l1870_action_invoke(&mut instance);
    c1853_l1871_action_invoke(&mut instance);
    c1854_l1872_action_invoke(&mut instance);
    c1855_l1873_action_invoke(&mut instance);
    c1856_l1874_action_invoke(&mut instance);
    c1857_l1875_action_invoke(&mut instance);
    c1858_l1876_action_invoke(&mut instance);
    c1859_l1877_action_invoke(&mut instance);
    c1860_l1878_action_invoke(&mut instance);
    c1861_l1879_action_invoke(&mut instance);
    c1862_l1880_action_invoke(&mut instance);
    c1863_l1881_action_invoke(&mut instance);
    c1864_l1882_action_invoke(&mut instance);
    c1865_l1883_action_invoke(&mut instance);
    c1866_l1884_action_invoke(&mut instance);
    c1867_l1885_action_invoke(&mut instance);
    c1868_l1886_action_invoke(&mut instance);
    c1869_l1887_action_invoke(&mut instance);
    c1870_l1888_action_invoke(&mut instance);
    c1871_l1889_action_invoke(&mut instance);
    c1872_l1890_action_invoke(&mut instance);
    c1873_l1891_assert_return_canonical_nan(&mut instance);
    c1874_l1892_assert_return_arithmetic_nan(&mut instance);
    c1875_l1893_assert_return_canonical_nan(&mut instance);
    c1876_l1894_assert_return_arithmetic_nan(&mut instance);
    c1877_l1895_assert_return_canonical_nan(&mut instance);
    c1878_l1896_assert_return_arithmetic_nan(&mut instance);
    c1879_l1897_assert_return_canonical_nan(&mut instance);
    c1880_l1898_assert_return_arithmetic_nan(&mut instance);
    c1881_l1899_action_invoke(&mut instance);
    c1882_l1900_action_invoke(&mut instance);
    c1883_l1901_action_invoke(&mut instance);
    c1884_l1902_action_invoke(&mut instance);
    c1885_l1903_action_invoke(&mut instance);
    c1886_l1904_action_invoke(&mut instance);
    c1887_l1905_action_invoke(&mut instance);
    c1888_l1906_action_invoke(&mut instance);
    c1889_l1907_action_invoke(&mut instance);
    c1890_l1908_action_invoke(&mut instance);
    c1891_l1909_action_invoke(&mut instance);
    c1892_l1910_action_invoke(&mut instance);
    c1893_l1911_action_invoke(&mut instance);
    c1894_l1912_action_invoke(&mut instance);
    c1895_l1913_action_invoke(&mut instance);
    c1896_l1914_action_invoke(&mut instance);
    c1897_l1915_action_invoke(&mut instance);
    c1898_l1916_action_invoke(&mut instance);
    c1899_l1917_action_invoke(&mut instance);
    c1900_l1918_action_invoke(&mut instance);
    c1901_l1919_action_invoke(&mut instance);
    c1902_l1920_action_invoke(&mut instance);
    c1903_l1921_action_invoke(&mut instance);
    c1904_l1922_action_invoke(&mut instance);
    c1905_l1923_action_invoke(&mut instance);
    c1906_l1924_action_invoke(&mut instance);
    c1907_l1925_action_invoke(&mut instance);
    c1908_l1926_action_invoke(&mut instance);
    c1909_l1927_action_invoke(&mut instance);
    c1910_l1928_action_invoke(&mut instance);
    c1911_l1929_action_invoke(&mut instance);
    c1912_l1930_action_invoke(&mut instance);
    c1913_l1931_assert_return_canonical_nan(&mut instance);
    c1914_l1932_assert_return_arithmetic_nan(&mut instance);
    c1915_l1933_assert_return_canonical_nan(&mut instance);
    c1916_l1934_assert_return_arithmetic_nan(&mut instance);
    c1917_l1935_assert_return_canonical_nan(&mut instance);
    c1918_l1936_assert_return_arithmetic_nan(&mut instance);
    c1919_l1937_assert_return_canonical_nan(&mut instance);
    c1920_l1938_assert_return_arithmetic_nan(&mut instance);
    c1921_l1939_assert_return_canonical_nan(&mut instance);
    c1922_l1940_assert_return_arithmetic_nan(&mut instance);
    c1923_l1941_assert_return_canonical_nan(&mut instance);
    c1924_l1942_assert_return_arithmetic_nan(&mut instance);
    c1925_l1943_assert_return_canonical_nan(&mut instance);
    c1926_l1944_assert_return_arithmetic_nan(&mut instance);
    c1927_l1945_assert_return_canonical_nan(&mut instance);
    c1928_l1946_assert_return_arithmetic_nan(&mut instance);
    c1929_l1947_assert_return_canonical_nan(&mut instance);
    c1930_l1948_assert_return_arithmetic_nan(&mut instance);
    c1931_l1949_assert_return_canonical_nan(&mut instance);
    c1932_l1950_assert_return_arithmetic_nan(&mut instance);
    c1933_l1951_assert_return_canonical_nan(&mut instance);
    c1934_l1952_assert_return_arithmetic_nan(&mut instance);
    c1935_l1953_assert_return_canonical_nan(&mut instance);
    c1936_l1954_assert_return_arithmetic_nan(&mut instance);
    c1937_l1955_assert_return_canonical_nan(&mut instance);
    c1938_l1956_assert_return_arithmetic_nan(&mut instance);
    c1939_l1957_assert_return_canonical_nan(&mut instance);
    c1940_l1958_assert_return_arithmetic_nan(&mut instance);
    c1941_l1959_assert_return_canonical_nan(&mut instance);
    c1942_l1960_assert_return_arithmetic_nan(&mut instance);
    c1943_l1961_assert_return_canonical_nan(&mut instance);
    c1944_l1962_assert_return_arithmetic_nan(&mut instance);
    c1945_l1963_assert_return_canonical_nan(&mut instance);
    c1946_l1964_assert_return_arithmetic_nan(&mut instance);
    c1947_l1965_assert_return_canonical_nan(&mut instance);
    c1948_l1966_assert_return_arithmetic_nan(&mut instance);
    c1949_l1967_assert_return_canonical_nan(&mut instance);
    c1950_l1968_assert_return_arithmetic_nan(&mut instance);
    c1951_l1969_assert_return_canonical_nan(&mut instance);
    c1952_l1970_assert_return_arithmetic_nan(&mut instance);
    c1953_l1971_assert_return_canonical_nan(&mut instance);
    c1954_l1972_assert_return_arithmetic_nan(&mut instance);
    c1955_l1973_assert_return_canonical_nan(&mut instance);
    c1956_l1974_assert_return_arithmetic_nan(&mut instance);
    c1957_l1975_assert_return_canonical_nan(&mut instance);
    c1958_l1976_assert_return_arithmetic_nan(&mut instance);
    c1959_l1977_assert_return_canonical_nan(&mut instance);
    c1960_l1978_assert_return_arithmetic_nan(&mut instance);
    c1961_l1979_assert_return_canonical_nan(&mut instance);
    c1962_l1980_assert_return_arithmetic_nan(&mut instance);
    c1963_l1981_assert_return_canonical_nan(&mut instance);
    c1964_l1982_assert_return_arithmetic_nan(&mut instance);
    c1965_l1983_assert_return_canonical_nan(&mut instance);
    c1966_l1984_assert_return_arithmetic_nan(&mut instance);
    c1967_l1985_assert_return_canonical_nan(&mut instance);
    c1968_l1986_assert_return_arithmetic_nan(&mut instance);
    c1969_l1987_assert_return_canonical_nan(&mut instance);
    c1970_l1988_assert_return_arithmetic_nan(&mut instance);
    c1971_l1989_assert_return_canonical_nan(&mut instance);
    c1972_l1990_assert_return_arithmetic_nan(&mut instance);
    c1973_l1991_assert_return_canonical_nan(&mut instance);
    c1974_l1992_assert_return_arithmetic_nan(&mut instance);
    c1975_l1993_assert_return_canonical_nan(&mut instance);
    c1976_l1994_assert_return_arithmetic_nan(&mut instance);
    c1977_l1995_assert_return_canonical_nan(&mut instance);
    c1978_l1996_assert_return_arithmetic_nan(&mut instance);
    c1979_l1997_assert_return_canonical_nan(&mut instance);
    c1980_l1998_assert_return_arithmetic_nan(&mut instance);
    c1981_l1999_assert_return_canonical_nan(&mut instance);
    c1982_l2000_assert_return_arithmetic_nan(&mut instance);
    c1983_l2001_assert_return_canonical_nan(&mut instance);
    c1984_l2002_assert_return_arithmetic_nan(&mut instance);
    c1985_l2003_assert_return_canonical_nan(&mut instance);
    c1986_l2004_assert_return_arithmetic_nan(&mut instance);
    c1987_l2005_assert_return_arithmetic_nan(&mut instance);
    c1988_l2006_assert_return_arithmetic_nan(&mut instance);
    c1989_l2007_assert_return_canonical_nan(&mut instance);
    c1990_l2008_assert_return_arithmetic_nan(&mut instance);
    c1991_l2009_assert_return_arithmetic_nan(&mut instance);
    c1992_l2010_assert_return_arithmetic_nan(&mut instance);
    c1993_l2011_assert_return_canonical_nan(&mut instance);
    c1994_l2012_assert_return_arithmetic_nan(&mut instance);
    c1995_l2013_assert_return_arithmetic_nan(&mut instance);
    c1996_l2014_assert_return_arithmetic_nan(&mut instance);
    c1997_l2015_assert_return_canonical_nan(&mut instance);
    c1998_l2016_assert_return_arithmetic_nan(&mut instance);
    c1999_l2017_assert_return_arithmetic_nan(&mut instance);
    c2000_l2018_assert_return_arithmetic_nan(&mut instance);
    c2001_l2019_action_invoke(&mut instance);
    c2002_l2020_action_invoke(&mut instance);
    c2003_l2021_action_invoke(&mut instance);
    c2004_l2022_action_invoke(&mut instance);
    c2005_l2023_action_invoke(&mut instance);
    c2006_l2024_action_invoke(&mut instance);
    c2007_l2025_action_invoke(&mut instance);
    c2008_l2026_action_invoke(&mut instance);
    c2009_l2027_action_invoke(&mut instance);
    c2010_l2028_action_invoke(&mut instance);
    c2011_l2029_action_invoke(&mut instance);
    c2012_l2030_action_invoke(&mut instance);
    c2013_l2031_action_invoke(&mut instance);
    c2014_l2032_action_invoke(&mut instance);
    c2015_l2033_action_invoke(&mut instance);
    c2016_l2034_action_invoke(&mut instance);
    c2017_l2035_action_invoke(&mut instance);
    c2018_l2036_action_invoke(&mut instance);
    c2019_l2037_action_invoke(&mut instance);
    c2020_l2038_action_invoke(&mut instance);
    c2021_l2039_action_invoke(&mut instance);
    c2022_l2040_action_invoke(&mut instance);
    c2023_l2041_action_invoke(&mut instance);
    c2024_l2042_action_invoke(&mut instance);
    c2025_l2043_action_invoke(&mut instance);
    c2026_l2044_action_invoke(&mut instance);
    c2027_l2045_action_invoke(&mut instance);
    c2028_l2046_action_invoke(&mut instance);
    c2029_l2047_action_invoke(&mut instance);
    c2030_l2048_action_invoke(&mut instance);
    c2031_l2049_action_invoke(&mut instance);
    c2032_l2050_action_invoke(&mut instance);
    c2033_l2051_assert_return_canonical_nan(&mut instance);
    c2034_l2052_assert_return_arithmetic_nan(&mut instance);
    c2035_l2053_assert_return_canonical_nan(&mut instance);
    c2036_l2054_assert_return_arithmetic_nan(&mut instance);
    c2037_l2055_assert_return_canonical_nan(&mut instance);
    c2038_l2056_assert_return_arithmetic_nan(&mut instance);
    c2039_l2057_assert_return_canonical_nan(&mut instance);
    c2040_l2058_assert_return_arithmetic_nan(&mut instance);
    c2041_l2059_action_invoke(&mut instance);
    c2042_l2060_action_invoke(&mut instance);
    c2043_l2061_action_invoke(&mut instance);
    c2044_l2062_action_invoke(&mut instance);
    c2045_l2063_action_invoke(&mut instance);
    c2046_l2064_action_invoke(&mut instance);
    c2047_l2065_action_invoke(&mut instance);
    c2048_l2066_action_invoke(&mut instance);
    c2049_l2067_action_invoke(&mut instance);
    c2050_l2068_action_invoke(&mut instance);
    c2051_l2069_action_invoke(&mut instance);
    c2052_l2070_action_invoke(&mut instance);
    c2053_l2071_action_invoke(&mut instance);
    c2054_l2072_action_invoke(&mut instance);
    c2055_l2073_action_invoke(&mut instance);
    c2056_l2074_action_invoke(&mut instance);
    c2057_l2075_action_invoke(&mut instance);
    c2058_l2076_action_invoke(&mut instance);
    c2059_l2077_action_invoke(&mut instance);
    c2060_l2078_action_invoke(&mut instance);
    c2061_l2079_action_invoke(&mut instance);
    c2062_l2080_action_invoke(&mut instance);
    c2063_l2081_action_invoke(&mut instance);
    c2064_l2082_action_invoke(&mut instance);
    c2065_l2083_action_invoke(&mut instance);
    c2066_l2084_action_invoke(&mut instance);
    c2067_l2085_action_invoke(&mut instance);
    c2068_l2086_action_invoke(&mut instance);
    c2069_l2087_action_invoke(&mut instance);
    c2070_l2088_action_invoke(&mut instance);
    c2071_l2089_action_invoke(&mut instance);
    c2072_l2090_action_invoke(&mut instance);
    c2073_l2091_assert_return_canonical_nan(&mut instance);
    c2074_l2092_assert_return_arithmetic_nan(&mut instance);
    c2075_l2093_assert_return_canonical_nan(&mut instance);
    c2076_l2094_assert_return_arithmetic_nan(&mut instance);
    c2077_l2095_assert_return_canonical_nan(&mut instance);
    c2078_l2096_assert_return_arithmetic_nan(&mut instance);
    c2079_l2097_assert_return_canonical_nan(&mut instance);
    c2080_l2098_assert_return_arithmetic_nan(&mut instance);
    c2081_l2099_action_invoke(&mut instance);
    c2082_l2100_action_invoke(&mut instance);
    c2083_l2101_action_invoke(&mut instance);
    c2084_l2102_action_invoke(&mut instance);
    c2085_l2103_action_invoke(&mut instance);
    c2086_l2104_action_invoke(&mut instance);
    c2087_l2105_action_invoke(&mut instance);
    c2088_l2106_action_invoke(&mut instance);
    c2089_l2107_action_invoke(&mut instance);
    c2090_l2108_action_invoke(&mut instance);
    c2091_l2109_action_invoke(&mut instance);
    c2092_l2110_action_invoke(&mut instance);
    c2093_l2111_action_invoke(&mut instance);
    c2094_l2112_action_invoke(&mut instance);
    c2095_l2113_action_invoke(&mut instance);
    c2096_l2114_action_invoke(&mut instance);
    c2097_l2115_action_invoke(&mut instance);
    c2098_l2116_action_invoke(&mut instance);
    c2099_l2117_action_invoke(&mut instance);
    c2100_l2118_action_invoke(&mut instance);
    c2101_l2119_action_invoke(&mut instance);
    c2102_l2120_action_invoke(&mut instance);
    c2103_l2121_action_invoke(&mut instance);
    c2104_l2122_action_invoke(&mut instance);
    c2105_l2123_action_invoke(&mut instance);
    c2106_l2124_action_invoke(&mut instance);
    c2107_l2125_action_invoke(&mut instance);
    c2108_l2126_action_invoke(&mut instance);
    c2109_l2127_action_invoke(&mut instance);
    c2110_l2128_action_invoke(&mut instance);
    c2111_l2129_action_invoke(&mut instance);
    c2112_l2130_action_invoke(&mut instance);
    c2113_l2131_assert_return_canonical_nan(&mut instance);
    c2114_l2132_assert_return_arithmetic_nan(&mut instance);
    c2115_l2133_assert_return_canonical_nan(&mut instance);
    c2116_l2134_assert_return_arithmetic_nan(&mut instance);
    c2117_l2135_assert_return_canonical_nan(&mut instance);
    c2118_l2136_assert_return_arithmetic_nan(&mut instance);
    c2119_l2137_assert_return_canonical_nan(&mut instance);
    c2120_l2138_assert_return_arithmetic_nan(&mut instance);
    c2121_l2139_action_invoke(&mut instance);
    c2122_l2140_action_invoke(&mut instance);
    c2123_l2141_action_invoke(&mut instance);
    c2124_l2142_action_invoke(&mut instance);
    c2125_l2143_action_invoke(&mut instance);
    c2126_l2144_action_invoke(&mut instance);
    c2127_l2145_action_invoke(&mut instance);
    c2128_l2146_action_invoke(&mut instance);
    c2129_l2147_action_invoke(&mut instance);
    c2130_l2148_action_invoke(&mut instance);
    c2131_l2149_action_invoke(&mut instance);
    c2132_l2150_action_invoke(&mut instance);
    c2133_l2151_action_invoke(&mut instance);
    c2134_l2152_action_invoke(&mut instance);
    c2135_l2153_action_invoke(&mut instance);
    c2136_l2154_action_invoke(&mut instance);
    c2137_l2155_action_invoke(&mut instance);
    c2138_l2156_action_invoke(&mut instance);
    c2139_l2157_action_invoke(&mut instance);
    c2140_l2158_action_invoke(&mut instance);
    c2141_l2159_action_invoke(&mut instance);
    c2142_l2160_action_invoke(&mut instance);
    c2143_l2161_action_invoke(&mut instance);
    c2144_l2162_action_invoke(&mut instance);
    c2145_l2163_action_invoke(&mut instance);
    c2146_l2164_action_invoke(&mut instance);
    c2147_l2165_action_invoke(&mut instance);
    c2148_l2166_action_invoke(&mut instance);
    c2149_l2167_action_invoke(&mut instance);
    c2150_l2168_action_invoke(&mut instance);
    c2151_l2169_action_invoke(&mut instance);
    c2152_l2170_action_invoke(&mut instance);
    c2153_l2171_assert_return_canonical_nan(&mut instance);
    c2154_l2172_assert_return_arithmetic_nan(&mut instance);
    c2155_l2173_assert_return_canonical_nan(&mut instance);
    c2156_l2174_assert_return_arithmetic_nan(&mut instance);
    c2157_l2175_assert_return_canonical_nan(&mut instance);
    c2158_l2176_assert_return_arithmetic_nan(&mut instance);
    c2159_l2177_assert_return_canonical_nan(&mut instance);
    c2160_l2178_assert_return_arithmetic_nan(&mut instance);
    c2161_l2179_action_invoke(&mut instance);
    c2162_l2180_action_invoke(&mut instance);
    c2163_l2181_action_invoke(&mut instance);
    c2164_l2182_action_invoke(&mut instance);
    c2165_l2183_action_invoke(&mut instance);
    c2166_l2184_action_invoke(&mut instance);
    c2167_l2185_action_invoke(&mut instance);
    c2168_l2186_action_invoke(&mut instance);
    c2169_l2187_action_invoke(&mut instance);
    c2170_l2188_action_invoke(&mut instance);
    c2171_l2189_action_invoke(&mut instance);
    c2172_l2190_action_invoke(&mut instance);
    c2173_l2191_action_invoke(&mut instance);
    c2174_l2192_action_invoke(&mut instance);
    c2175_l2193_action_invoke(&mut instance);
    c2176_l2194_action_invoke(&mut instance);
    c2177_l2195_action_invoke(&mut instance);
    c2178_l2196_action_invoke(&mut instance);
    c2179_l2197_action_invoke(&mut instance);
    c2180_l2198_action_invoke(&mut instance);
    c2181_l2199_action_invoke(&mut instance);
    c2182_l2200_action_invoke(&mut instance);
    c2183_l2201_action_invoke(&mut instance);
    c2184_l2202_action_invoke(&mut instance);
    c2185_l2203_action_invoke(&mut instance);
    c2186_l2204_action_invoke(&mut instance);
    c2187_l2205_action_invoke(&mut instance);
    c2188_l2206_action_invoke(&mut instance);
    c2189_l2207_action_invoke(&mut instance);
    c2190_l2208_action_invoke(&mut instance);
    c2191_l2209_action_invoke(&mut instance);
    c2192_l2210_action_invoke(&mut instance);
    c2193_l2211_assert_return_canonical_nan(&mut instance);
    c2194_l2212_assert_return_arithmetic_nan(&mut instance);
    c2195_l2213_assert_return_canonical_nan(&mut instance);
    c2196_l2214_assert_return_arithmetic_nan(&mut instance);
    c2197_l2215_assert_return_canonical_nan(&mut instance);
    c2198_l2216_assert_return_arithmetic_nan(&mut instance);
    c2199_l2217_assert_return_canonical_nan(&mut instance);
    c2200_l2218_assert_return_arithmetic_nan(&mut instance);
    c2201_l2219_action_invoke(&mut instance);
    c2202_l2220_action_invoke(&mut instance);
    c2203_l2221_action_invoke(&mut instance);
    c2204_l2222_action_invoke(&mut instance);
    c2205_l2223_action_invoke(&mut instance);
    c2206_l2224_action_invoke(&mut instance);
    c2207_l2225_action_invoke(&mut instance);
    c2208_l2226_action_invoke(&mut instance);
    c2209_l2227_action_invoke(&mut instance);
    c2210_l2228_action_invoke(&mut instance);
    c2211_l2229_action_invoke(&mut instance);
    c2212_l2230_action_invoke(&mut instance);
    c2213_l2231_action_invoke(&mut instance);
    c2214_l2232_action_invoke(&mut instance);
    c2215_l2233_action_invoke(&mut instance);
    c2216_l2234_action_invoke(&mut instance);
    c2217_l2235_action_invoke(&mut instance);
    c2218_l2236_action_invoke(&mut instance);
    c2219_l2237_action_invoke(&mut instance);
    c2220_l2238_action_invoke(&mut instance);
    c2221_l2239_action_invoke(&mut instance);
    c2222_l2240_action_invoke(&mut instance);
    c2223_l2241_action_invoke(&mut instance);
    c2224_l2242_action_invoke(&mut instance);
    c2225_l2243_action_invoke(&mut instance);
    c2226_l2244_action_invoke(&mut instance);
    c2227_l2245_action_invoke(&mut instance);
    c2228_l2246_action_invoke(&mut instance);
    c2229_l2247_action_invoke(&mut instance);
    c2230_l2248_action_invoke(&mut instance);
    c2231_l2249_action_invoke(&mut instance);
    c2232_l2250_action_invoke(&mut instance);
    c2233_l2251_assert_return_canonical_nan(&mut instance);
    c2234_l2252_assert_return_arithmetic_nan(&mut instance);
    c2235_l2253_assert_return_canonical_nan(&mut instance);
    c2236_l2254_assert_return_arithmetic_nan(&mut instance);
    c2237_l2255_assert_return_canonical_nan(&mut instance);
    c2238_l2256_assert_return_arithmetic_nan(&mut instance);
    c2239_l2257_assert_return_canonical_nan(&mut instance);
    c2240_l2258_assert_return_arithmetic_nan(&mut instance);
    c2241_l2259_action_invoke(&mut instance);
    c2242_l2260_action_invoke(&mut instance);
    c2243_l2261_action_invoke(&mut instance);
    c2244_l2262_action_invoke(&mut instance);
    c2245_l2263_action_invoke(&mut instance);
    c2246_l2264_action_invoke(&mut instance);
    c2247_l2265_action_invoke(&mut instance);
    c2248_l2266_action_invoke(&mut instance);
    c2249_l2267_action_invoke(&mut instance);
    c2250_l2268_action_invoke(&mut instance);
    c2251_l2269_action_invoke(&mut instance);
    c2252_l2270_action_invoke(&mut instance);
    c2253_l2271_action_invoke(&mut instance);
    c2254_l2272_action_invoke(&mut instance);
    c2255_l2273_action_invoke(&mut instance);
    c2256_l2274_action_invoke(&mut instance);
    c2257_l2275_action_invoke(&mut instance);
    c2258_l2276_action_invoke(&mut instance);
    c2259_l2277_action_invoke(&mut instance);
    c2260_l2278_action_invoke(&mut instance);
    c2261_l2279_action_invoke(&mut instance);
    c2262_l2280_action_invoke(&mut instance);
    c2263_l2281_action_invoke(&mut instance);
    c2264_l2282_action_invoke(&mut instance);
    c2265_l2283_action_invoke(&mut instance);
    c2266_l2284_action_invoke(&mut instance);
    c2267_l2285_action_invoke(&mut instance);
    c2268_l2286_action_invoke(&mut instance);
    c2269_l2287_action_invoke(&mut instance);
    c2270_l2288_action_invoke(&mut instance);
    c2271_l2289_action_invoke(&mut instance);
    c2272_l2290_action_invoke(&mut instance);
    c2273_l2291_assert_return_canonical_nan(&mut instance);
    c2274_l2292_assert_return_arithmetic_nan(&mut instance);
    c2275_l2293_assert_return_canonical_nan(&mut instance);
    c2276_l2294_assert_return_arithmetic_nan(&mut instance);
    c2277_l2295_assert_return_canonical_nan(&mut instance);
    c2278_l2296_assert_return_arithmetic_nan(&mut instance);
    c2279_l2297_assert_return_canonical_nan(&mut instance);
    c2280_l2298_assert_return_arithmetic_nan(&mut instance);
    c2281_l2299_action_invoke(&mut instance);
    c2282_l2300_action_invoke(&mut instance);
    c2283_l2301_action_invoke(&mut instance);
    c2284_l2302_action_invoke(&mut instance);
    c2285_l2303_action_invoke(&mut instance);
    c2286_l2304_action_invoke(&mut instance);
    c2287_l2305_action_invoke(&mut instance);
    c2288_l2306_action_invoke(&mut instance);
    c2289_l2307_action_invoke(&mut instance);
    c2290_l2308_action_invoke(&mut instance);
    c2291_l2309_action_invoke(&mut instance);
    c2292_l2310_action_invoke(&mut instance);
    c2293_l2311_action_invoke(&mut instance);
    c2294_l2312_action_invoke(&mut instance);
    c2295_l2313_action_invoke(&mut instance);
    c2296_l2314_action_invoke(&mut instance);
    c2297_l2315_action_invoke(&mut instance);
    c2298_l2316_action_invoke(&mut instance);
    c2299_l2317_action_invoke(&mut instance);
    c2300_l2318_action_invoke(&mut instance);
    c2301_l2319_action_invoke(&mut instance);
    c2302_l2320_action_invoke(&mut instance);
    c2303_l2321_action_invoke(&mut instance);
    c2304_l2322_action_invoke(&mut instance);
    c2305_l2323_action_invoke(&mut instance);
    c2306_l2324_action_invoke(&mut instance);
    c2307_l2325_action_invoke(&mut instance);
    c2308_l2326_action_invoke(&mut instance);
    c2309_l2327_action_invoke(&mut instance);
    c2310_l2328_action_invoke(&mut instance);
    c2311_l2329_action_invoke(&mut instance);
    c2312_l2330_action_invoke(&mut instance);
    c2313_l2331_assert_return_canonical_nan(&mut instance);
    c2314_l2332_assert_return_arithmetic_nan(&mut instance);
    c2315_l2333_assert_return_canonical_nan(&mut instance);
    c2316_l2334_assert_return_arithmetic_nan(&mut instance);
    c2317_l2335_assert_return_canonical_nan(&mut instance);
    c2318_l2336_assert_return_arithmetic_nan(&mut instance);
    c2319_l2337_assert_return_canonical_nan(&mut instance);
    c2320_l2338_assert_return_arithmetic_nan(&mut instance);
    c2321_l2339_assert_return_canonical_nan(&mut instance);
    c2322_l2340_assert_return_arithmetic_nan(&mut instance);
    c2323_l2341_assert_return_canonical_nan(&mut instance);
    c2324_l2342_assert_return_arithmetic_nan(&mut instance);
    c2325_l2343_assert_return_canonical_nan(&mut instance);
    c2326_l2344_assert_return_arithmetic_nan(&mut instance);
    c2327_l2345_assert_return_canonical_nan(&mut instance);
    c2328_l2346_assert_return_arithmetic_nan(&mut instance);
    c2329_l2347_assert_return_canonical_nan(&mut instance);
    c2330_l2348_assert_return_arithmetic_nan(&mut instance);
    c2331_l2349_assert_return_canonical_nan(&mut instance);
    c2332_l2350_assert_return_arithmetic_nan(&mut instance);
    c2333_l2351_assert_return_canonical_nan(&mut instance);
    c2334_l2352_assert_return_arithmetic_nan(&mut instance);
    c2335_l2353_assert_return_canonical_nan(&mut instance);
    c2336_l2354_assert_return_arithmetic_nan(&mut instance);
    c2337_l2355_assert_return_canonical_nan(&mut instance);
    c2338_l2356_assert_return_arithmetic_nan(&mut instance);
    c2339_l2357_assert_return_canonical_nan(&mut instance);
    c2340_l2358_assert_return_arithmetic_nan(&mut instance);
    c2341_l2359_assert_return_canonical_nan(&mut instance);
    c2342_l2360_assert_return_arithmetic_nan(&mut instance);
    c2343_l2361_assert_return_canonical_nan(&mut instance);
    c2344_l2362_assert_return_arithmetic_nan(&mut instance);
    c2345_l2363_assert_return_canonical_nan(&mut instance);
    c2346_l2364_assert_return_arithmetic_nan(&mut instance);
    c2347_l2365_assert_return_canonical_nan(&mut instance);
    c2348_l2366_assert_return_arithmetic_nan(&mut instance);
    c2349_l2367_assert_return_canonical_nan(&mut instance);
    c2350_l2368_assert_return_arithmetic_nan(&mut instance);
    c2351_l2369_assert_return_canonical_nan(&mut instance);
    c2352_l2370_assert_return_arithmetic_nan(&mut instance);
    c2353_l2371_assert_return_canonical_nan(&mut instance);
    c2354_l2372_assert_return_arithmetic_nan(&mut instance);
    c2355_l2373_assert_return_canonical_nan(&mut instance);
    c2356_l2374_assert_return_arithmetic_nan(&mut instance);
    c2357_l2375_assert_return_canonical_nan(&mut instance);
    c2358_l2376_assert_return_arithmetic_nan(&mut instance);
    c2359_l2377_assert_return_canonical_nan(&mut instance);
    c2360_l2378_assert_return_arithmetic_nan(&mut instance);
    c2361_l2379_assert_return_canonical_nan(&mut instance);
    c2362_l2380_assert_return_arithmetic_nan(&mut instance);
    c2363_l2381_assert_return_canonical_nan(&mut instance);
    c2364_l2382_assert_return_arithmetic_nan(&mut instance);
    c2365_l2383_assert_return_canonical_nan(&mut instance);
    c2366_l2384_assert_return_arithmetic_nan(&mut instance);
    c2367_l2385_assert_return_canonical_nan(&mut instance);
    c2368_l2386_assert_return_arithmetic_nan(&mut instance);
    c2369_l2387_assert_return_canonical_nan(&mut instance);
    c2370_l2388_assert_return_arithmetic_nan(&mut instance);
    c2371_l2389_assert_return_canonical_nan(&mut instance);
    c2372_l2390_assert_return_arithmetic_nan(&mut instance);
    c2373_l2391_assert_return_canonical_nan(&mut instance);
    c2374_l2392_assert_return_arithmetic_nan(&mut instance);
    c2375_l2393_assert_return_canonical_nan(&mut instance);
    c2376_l2394_assert_return_arithmetic_nan(&mut instance);
    c2377_l2395_assert_return_canonical_nan(&mut instance);
    c2378_l2396_assert_return_arithmetic_nan(&mut instance);
    c2379_l2397_assert_return_canonical_nan(&mut instance);
    c2380_l2398_assert_return_arithmetic_nan(&mut instance);
    c2381_l2399_assert_return_canonical_nan(&mut instance);
    c2382_l2400_assert_return_arithmetic_nan(&mut instance);
    c2383_l2401_assert_return_canonical_nan(&mut instance);
    c2384_l2402_assert_return_arithmetic_nan(&mut instance);
    c2385_l2403_assert_return_canonical_nan(&mut instance);
    c2386_l2404_assert_return_arithmetic_nan(&mut instance);
    c2387_l2405_assert_return_arithmetic_nan(&mut instance);
    c2388_l2406_assert_return_arithmetic_nan(&mut instance);
    c2389_l2407_assert_return_canonical_nan(&mut instance);
    c2390_l2408_assert_return_arithmetic_nan(&mut instance);
    c2391_l2409_assert_return_arithmetic_nan(&mut instance);
    c2392_l2410_assert_return_arithmetic_nan(&mut instance);
    c2393_l2411_assert_return_canonical_nan(&mut instance);
    c2394_l2412_assert_return_arithmetic_nan(&mut instance);
    c2395_l2413_assert_return_arithmetic_nan(&mut instance);
    c2396_l2414_assert_return_arithmetic_nan(&mut instance);
    c2397_l2415_assert_return_canonical_nan(&mut instance);
    c2398_l2416_assert_return_arithmetic_nan(&mut instance);
    c2399_l2417_assert_return_arithmetic_nan(&mut instance);
    c2400_l2418_assert_return_arithmetic_nan(&mut instance);
    c2401_l2419_action_invoke(&mut instance);
    c2402_l2420_action_invoke(&mut instance);
    c2403_l2421_assert_return_canonical_nan(&mut instance);
    c2404_l2422_action_invoke(&mut instance);
    c2405_l2423_assert_return_canonical_nan(&mut instance);
    c2406_l2424_action_invoke(&mut instance);
    c2407_l2425_assert_return_canonical_nan(&mut instance);
    c2408_l2426_action_invoke(&mut instance);
    c2409_l2427_assert_return_canonical_nan(&mut instance);
    c2410_l2428_action_invoke(&mut instance);
    c2411_l2429_assert_return_canonical_nan(&mut instance);
    c2412_l2430_action_invoke(&mut instance);
    c2413_l2431_assert_return_canonical_nan(&mut instance);
    c2414_l2432_action_invoke(&mut instance);
    c2415_l2433_assert_return_canonical_nan(&mut instance);
    c2416_l2434_action_invoke(&mut instance);
    c2417_l2435_assert_return_canonical_nan(&mut instance);
    c2418_l2436_assert_return_arithmetic_nan(&mut instance);
    c2419_l2437_assert_return_canonical_nan(&mut instance);
    c2420_l2438_assert_return_arithmetic_nan(&mut instance);
    c2421_l2439_action_invoke(&mut instance);
    c2422_l2440_action_invoke(&mut instance);
    c2423_l2441_action_invoke(&mut instance);
    c2424_l2442_action_invoke(&mut instance);
    c2425_l2443_action_invoke(&mut instance);
    c2426_l2444_action_invoke(&mut instance);
    c2427_l2445_action_invoke(&mut instance);
    c2428_l2446_action_invoke(&mut instance);
    c2429_l2447_action_invoke(&mut instance);
    c2430_l2448_action_invoke(&mut instance);
    c2431_l2449_action_invoke(&mut instance);
    c2432_l2450_action_invoke(&mut instance);
    c2433_l2451_action_invoke(&mut instance);
    c2434_l2452_action_invoke(&mut instance);
    c2435_l2453_action_invoke(&mut instance);
    c2436_l2454_action_invoke(&mut instance);
    c2437_l2455_assert_return_canonical_nan(&mut instance);
    c2438_l2456_assert_return_arithmetic_nan(&mut instance);
    c2439_l2457_assert_return_canonical_nan(&mut instance);
    c2440_l2458_assert_return_arithmetic_nan(&mut instance);
    c2441_l2459_action_invoke(&mut instance);
    c2442_l2460_action_invoke(&mut instance);
    c2443_l2461_action_invoke(&mut instance);
    c2444_l2462_action_invoke(&mut instance);
    c2445_l2463_action_invoke(&mut instance);
    c2446_l2464_action_invoke(&mut instance);
    c2447_l2465_action_invoke(&mut instance);
    c2448_l2466_action_invoke(&mut instance);
    c2449_l2467_action_invoke(&mut instance);
    c2450_l2468_action_invoke(&mut instance);
    c2451_l2469_action_invoke(&mut instance);
    c2452_l2470_action_invoke(&mut instance);
    c2453_l2471_action_invoke(&mut instance);
    c2454_l2472_action_invoke(&mut instance);
    c2455_l2473_action_invoke(&mut instance);
    c2456_l2474_action_invoke(&mut instance);
    c2457_l2475_assert_return_canonical_nan(&mut instance);
    c2458_l2476_assert_return_arithmetic_nan(&mut instance);
    c2459_l2477_assert_return_canonical_nan(&mut instance);
    c2460_l2478_assert_return_arithmetic_nan(&mut instance);
    c2461_l2479_action_invoke(&mut instance);
    c2462_l2480_action_invoke(&mut instance);
    c2463_l2481_action_invoke(&mut instance);
    c2464_l2482_action_invoke(&mut instance);
    c2465_l2483_action_invoke(&mut instance);
    c2466_l2484_action_invoke(&mut instance);
    c2467_l2485_action_invoke(&mut instance);
    c2468_l2486_action_invoke(&mut instance);
    c2469_l2487_action_invoke(&mut instance);
    c2470_l2488_action_invoke(&mut instance);
    c2471_l2489_action_invoke(&mut instance);
    c2472_l2490_action_invoke(&mut instance);
    c2473_l2491_action_invoke(&mut instance);
    c2474_l2492_action_invoke(&mut instance);
    c2475_l2493_action_invoke(&mut instance);
    c2476_l2494_action_invoke(&mut instance);
    c2477_l2495_assert_return_canonical_nan(&mut instance);
    c2478_l2496_assert_return_arithmetic_nan(&mut instance);
    c2479_l2497_assert_return_canonical_nan(&mut instance);
    c2480_l2498_assert_return_arithmetic_nan(&mut instance);
    c2481_l2499_action_invoke(&mut instance);
    c2482_l2500_action_invoke(&mut instance);
    c2483_l2501_action_invoke(&mut instance);
    c2484_l2502_action_invoke(&mut instance);
    c2485_l2503_action_invoke(&mut instance);
    c2486_l2504_action_invoke(&mut instance);
    c2487_l2505_action_invoke(&mut instance);
    c2488_l2506_action_invoke(&mut instance);
    c2489_l2507_action_invoke(&mut instance);
    c2490_l2508_action_invoke(&mut instance);
    c2491_l2509_action_invoke(&mut instance);
    c2492_l2510_action_invoke(&mut instance);
    c2493_l2511_action_invoke(&mut instance);
    c2494_l2512_action_invoke(&mut instance);
    c2495_l2513_action_invoke(&mut instance);
    c2496_l2514_action_invoke(&mut instance);
    c2497_l2515_assert_return_canonical_nan(&mut instance);
    c2498_l2516_assert_return_arithmetic_nan(&mut instance);
    c2499_l2517_assert_return_canonical_nan(&mut instance);
    c2500_l2518_assert_return_arithmetic_nan(&mut instance);
}