diff --git a/spectests/README.md b/spectests/README.md index 69720e9c8..805b99a65 100644 --- a/spectests/README.md +++ b/spectests/README.md @@ -61,7 +61,7 @@ This spectests are currently covered: - float_exprs.wast ✅ - float_literals.wast ✅ - float_memory.wast ✅ -- float_misc.wast +- float_misc.wast ✅ - forward.wast - func.wast ✅ - func_ptrs.wast ✅ diff --git a/spectests/float_misc.wast b/spectests/float_misc.wast new file mode 100644 index 000000000..313534326 --- /dev/null +++ b/spectests/float_misc.wast @@ -0,0 +1,678 @@ +;; Platforms intended to run WebAssembly must support IEEE 754 arithmetic. +;; This testsuite is not currently sufficient for full IEEE 754 conformance +;; testing; platforms are currently expected to meet these requirements in +;; their own way (widely-used hardware platforms already do this). +;; +;; What this testsuite does test is that (a) the platform is basically IEEE 754 +;; rather than something else entirely, (b) it's configured correctly for +;; WebAssembly (rounding direction, exception masks, precision level, subnormal +;; mode, etc.), (c) the WebAssembly implementation doesn't perform any common +;; value-changing optimizations, and (d) that the WebAssembly implementation +;; doesn't exhibit any known implementation bugs. +;; +;; This file supplements f32.wast, f64.wast, f32_bitwise.wast, f64_bitwise.wast, +;; f32_cmp.wast, and f64_cmp.wast with additional single-instruction tests +;; covering additional miscellaneous interesting cases. + +(module + (func (export "f32.add") (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y))) + (func (export "f32.sub") (param $x f32) (param $y f32) (result f32) (f32.sub (get_local $x) (get_local $y))) + (func (export "f32.mul") (param $x f32) (param $y f32) (result f32) (f32.mul (get_local $x) (get_local $y))) + (func (export "f32.div") (param $x f32) (param $y f32) (result f32) (f32.div (get_local $x) (get_local $y))) + (func (export "f32.sqrt") (param $x f32) (result f32) (f32.sqrt (get_local $x))) + (func (export "f32.abs") (param $x f32) (result f32) (f32.abs (get_local $x))) + (func (export "f32.neg") (param $x f32) (result f32) (f32.neg (get_local $x))) + (func (export "f32.copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (get_local $x) (get_local $y))) + (func (export "f32.ceil") (param $x f32) (result f32) (f32.ceil (get_local $x))) + (func (export "f32.floor") (param $x f32) (result f32) (f32.floor (get_local $x))) + (func (export "f32.trunc") (param $x f32) (result f32) (f32.trunc (get_local $x))) + (func (export "f32.nearest") (param $x f32) (result f32) (f32.nearest (get_local $x))) + (func (export "f32.min") (param $x f32) (param $y f32) (result f32) (f32.min (get_local $x) (get_local $y))) + (func (export "f32.max") (param $x f32) (param $y f32) (result f32) (f32.max (get_local $x) (get_local $y))) + + (func (export "f64.add") (param $x f64) (param $y f64) (result f64) (f64.add (get_local $x) (get_local $y))) + (func (export "f64.sub") (param $x f64) (param $y f64) (result f64) (f64.sub (get_local $x) (get_local $y))) + (func (export "f64.mul") (param $x f64) (param $y f64) (result f64) (f64.mul (get_local $x) (get_local $y))) + (func (export "f64.div") (param $x f64) (param $y f64) (result f64) (f64.div (get_local $x) (get_local $y))) + (func (export "f64.sqrt") (param $x f64) (result f64) (f64.sqrt (get_local $x))) + (func (export "f64.abs") (param $x f64) (result f64) (f64.abs (get_local $x))) + (func (export "f64.neg") (param $x f64) (result f64) (f64.neg (get_local $x))) + (func (export "f64.copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (get_local $x) (get_local $y))) + (func (export "f64.ceil") (param $x f64) (result f64) (f64.ceil (get_local $x))) + (func (export "f64.floor") (param $x f64) (result f64) (f64.floor (get_local $x))) + (func (export "f64.trunc") (param $x f64) (result f64) (f64.trunc (get_local $x))) + (func (export "f64.nearest") (param $x f64) (result f64) (f64.nearest (get_local $x))) + (func (export "f64.min") (param $x f64) (param $y f64) (result f64) (f64.min (get_local $x) (get_local $y))) + (func (export "f64.max") (param $x f64) (param $y f64) (result f64) (f64.max (get_local $x) (get_local $y))) +) + +;; Miscellaneous values. +(assert_return (invoke "f32.add" (f32.const 1.1234567890) (f32.const 1.2345e-10)) (f32.const 1.123456789)) +(assert_return (invoke "f64.add" (f64.const 1.1234567890) (f64.const 1.2345e-10)) (f64.const 0x1.1f9add37c11f7p+0)) + +;; Test adding the greatest value to 1.0 that rounds back to 1.0, and the +;; least that rounds to something greater. +(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1p-24)) (f32.const 0x1.0p+0)) +(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1.000002p-24)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1p-53)) (f64.const 0x1.0p+0)) +(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1.0000000000001p-53)) (f64.const 0x1.0000000000001p+0)) + +;; Max subnormal + min subnormal = min normal. +(assert_return (invoke "f32.add" (f32.const 0x1p-149) (f32.const 0x1.fffffcp-127)) (f32.const 0x1p-126)) +(assert_return (invoke "f64.add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1p-1022)) + +;; Test for a case of double rounding, example from: +;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html +;; section 3.3.1: A typical problem: "double rounding" +(assert_return (invoke "f32.add" (f32.const 0x1p+31) (f32.const 1024.25)) (f32.const 0x1.000008p+31)) +(assert_return (invoke "f64.add" (f64.const 0x1p+63) (f64.const 1024.25)) (f64.const 0x1.0000000000001p+63)) + +;; Test a case that was "tricky" on MMIX. +;; http://mmix.cs.hm.edu/bugs/bug_rounding.html +(assert_return (invoke "f64.add" (f64.const -0x1p-1008) (f64.const 0x0.0000000001716p-1022)) (f64.const -0x1.fffffffffffffp-1009)) + +;; http://www.vinc17.org/software/tst-ieee754.xsl +(assert_return (invoke "f64.add" (f64.const 9007199254740992) (f64.const 1.00001)) (f64.const 9007199254740994)) + +;; http://www.vinc17.org/software/test.java +(assert_return (invoke "f64.add" (f64.const 9007199254740994) (f64.const 0x1.fffep-1)) (f64.const 9007199254740994)) + +;; Computations that round differently in ties-to-odd mode. +(assert_return (invoke "f32.add" (f32.const 0x1p23) (f32.const 0x1p-1)) (f32.const 0x1p23)) +(assert_return (invoke "f32.add" (f32.const 0x1.000002p+23) (f32.const 0x1p-1)) (f32.const 0x1.000004p+23)) +(assert_return (invoke "f64.add" (f64.const 0x1p52) (f64.const 0x1p-1)) (f64.const 0x1p52)) +(assert_return (invoke "f64.add" (f64.const 0x1.0000000000001p+52) (f64.const 0x1p-1)) (f64.const 0x1.0000000000002p+52)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.add" (f32.const -0x1.39675ap+102) (f32.const 0x1.76c94cp-99)) (f32.const -0x1.39675ap+102)) +(assert_return (invoke "f32.add" (f32.const 0x1.6c0f24p+67) (f32.const -0x1.2b92dp+52)) (f32.const 0x1.6c0cccp+67)) +(assert_return (invoke "f32.add" (f32.const 0x1.e62318p-83) (f32.const 0x1.f74abep-125)) (f32.const 0x1.e62318p-83)) +(assert_return (invoke "f32.add" (f32.const 0x1.2a71d4p+39) (f32.const -0x1.c9f10cp+55)) (f32.const -0x1.c9efe2p+55)) +(assert_return (invoke "f32.add" (f32.const 0x1.f8f736p-15) (f32.const 0x1.7bd45ep+106)) (f32.const 0x1.7bd45ep+106)) +(assert_return (invoke "f64.add" (f64.const 0x1.f33e1fbca27aap-413) (f64.const -0x1.6b192891ed61p+249)) (f64.const -0x1.6b192891ed61p+249)) +(assert_return (invoke "f64.add" (f64.const -0x1.46f75d130eeb1p+76) (f64.const 0x1.25275d6f7a4acp-184)) (f64.const -0x1.46f75d130eeb1p+76)) +(assert_return (invoke "f64.add" (f64.const 0x1.04dec9265a731p-148) (f64.const -0x1.11eed4e8c127cp-12)) (f64.const -0x1.11eed4e8c127cp-12)) +(assert_return (invoke "f64.add" (f64.const 0x1.05773b7166b0ap+497) (f64.const 0x1.134022f2da37bp+66)) (f64.const 0x1.05773b7166b0ap+497)) +(assert_return (invoke "f64.add" (f64.const 0x1.ef4f794282a82p+321) (f64.const 0x1.14a82266badep+394)) (f64.const 0x1.14a82266badep+394)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.add" (f32.const 0x1.1bf976p+72) (f32.const -0x1.7f5868p+20)) (f32.const 0x1.1bf976p+72)) +(assert_return (invoke "f32.add" (f32.const 0x1.7f9c6cp-45) (f32.const -0x1.b9bb0ep-78)) (f32.const 0x1.7f9c6cp-45)) +(assert_return (invoke "f32.add" (f32.const -0x1.32d1bcp-42) (f32.const 0x1.f7d214p+125)) (f32.const 0x1.f7d214p+125)) +(assert_return (invoke "f32.add" (f32.const -0x1.8e5c0ep-44) (f32.const -0x1.3afa4cp-106)) (f32.const -0x1.8e5c0ep-44)) +(assert_return (invoke "f32.add" (f32.const 0x1.13cd78p-10) (f32.const -0x1.3af316p-107)) (f32.const 0x1.13cd78p-10)) +(assert_return (invoke "f64.add" (f64.const 0x1.f8dd15ca97d4ap+179) (f64.const -0x1.367317d1fe8bfp-527)) (f64.const 0x1.f8dd15ca97d4ap+179)) +(assert_return (invoke "f64.add" (f64.const 0x1.5db08d739228cp+155) (f64.const -0x1.fb316fa147dcbp-61)) (f64.const 0x1.5db08d739228cp+155)) +(assert_return (invoke "f64.add" (f64.const 0x1.bbb403cb85c07p-404) (f64.const -0x1.7e44046b8bbf3p-979)) (f64.const 0x1.bbb403cb85c07p-404)) +(assert_return (invoke "f64.add" (f64.const -0x1.34d38af291831p+147) (f64.const -0x1.9890b47439953p+139)) (f64.const -0x1.366c1ba705bcap+147)) +(assert_return (invoke "f64.add" (f64.const -0x1.b61dedf4e0306p+3) (f64.const 0x1.09e2f31773c4ap+290)) (f64.const 0x1.09e2f31773c4ap+290)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.add" (f32.const -0x1.129bd8p-117) (f32.const 0x1.c75012p-43)) (f32.const 0x1.c75012p-43)) +(assert_return (invoke "f32.add" (f32.const -0x1.c204a2p-16) (f32.const 0x1.80b132p-27)) (f32.const -0x1.c1d48cp-16)) +(assert_return (invoke "f32.add" (f32.const -0x1.decc1cp+36) (f32.const 0x1.c688dap-109)) (f32.const -0x1.decc1cp+36)) +(assert_return (invoke "f32.add" (f32.const 0x1.61ce6ap-118) (f32.const -0x1.772892p+30)) (f32.const -0x1.772892p+30)) +(assert_return (invoke "f32.add" (f32.const -0x1.3dc826p-120) (f32.const 0x1.fc3f66p+95)) (f32.const 0x1.fc3f66p+95)) +(assert_return (invoke "f64.add" (f64.const 0x1.bf68acc263a0fp-777) (f64.const -0x1.5f9352965e5a6p+1004)) (f64.const -0x1.5f9352965e5a6p+1004)) +(assert_return (invoke "f64.add" (f64.const -0x1.76eaa70911f51p+516) (f64.const -0x1.2d746324ce47ap+493)) (f64.const -0x1.76eaa963fabb6p+516)) +(assert_return (invoke "f64.add" (f64.const -0x1.b637d82c15a7ap-967) (f64.const 0x1.cc654ccab4152p-283)) (f64.const 0x1.cc654ccab4152p-283)) +(assert_return (invoke "f64.add" (f64.const -0x1.a5b1fb66e846ep-509) (f64.const 0x1.4bdd36f0bb5ccp-860)) (f64.const -0x1.a5b1fb66e846ep-509)) +(assert_return (invoke "f64.add" (f64.const -0x1.14108da880f9ep+966) (f64.const 0x1.417f35701e89fp+800)) (f64.const -0x1.14108da880f9ep+966)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.add" (f64.const -0x1.fa0caf21ffebcp+804) (f64.const 0x1.4ca8fdcff89f9p+826)) (f64.const 0x1.4ca8f5e7c5e31p+826)) +(assert_return (invoke "f64.add" (f64.const 0x1.016f1fcbdfd38p+784) (f64.const 0x1.375dffcbc9a2cp+746)) (f64.const 0x1.016f1fcbe4b0fp+784)) +(assert_return (invoke "f64.add" (f64.const -0x1.dffda6d5bff3ap+624) (f64.const 0x1.f9e8cc2dff782p+674)) (f64.const 0x1.f9e8cc2dff77bp+674)) +(assert_return (invoke "f64.add" (f64.const 0x1.fff4b43687dfbp+463) (f64.const 0x1.0fd5617c4a809p+517)) (f64.const 0x1.0fd5617c4a809p+517)) +(assert_return (invoke "f64.add" (f64.const 0x1.535d380035da2p-995) (f64.const 0x1.cce37dddbb73bp-963)) (f64.const 0x1.cce37ddf0ed0fp-963)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.add" (f64.const -0x1.d91cd3fc0c66fp+752) (f64.const -0x1.4e18c80229734p+952)) (f64.const -0x1.4e18c80229734p+952)) +(assert_return (invoke "f64.add" (f64.const 0x1.afc70fd36e372p+193) (f64.const -0x1.bd10a9b377b46p+273)) (f64.const -0x1.bd10a9b377b46p+273)) +(assert_return (invoke "f64.add" (f64.const -0x1.2abd570b078b2p+302) (f64.const 0x1.b3c1ad759cb5bp-423)) (f64.const -0x1.2abd570b078b2p+302)) +(assert_return (invoke "f64.add" (f64.const -0x1.5b2ae84c0686cp-317) (f64.const -0x1.dba7a1c022823p+466)) (f64.const -0x1.dba7a1c022823p+466)) +(assert_return (invoke "f64.add" (f64.const -0x1.ac627bd7cbf38p-198) (f64.const 0x1.2312e265b8d59p-990)) (f64.const -0x1.ac627bd7cbf38p-198)) + +;; Computations that utilize the maximum exponent value to avoid overflow. +(assert_return (invoke "f32.add" (f32.const 0x1.2b91ap+116) (f32.const 0x1.cbcd52p+127)) (f32.const 0x1.cbf2c4p+127)) +(assert_return (invoke "f32.add" (f32.const 0x1.96f392p+127) (f32.const -0x1.6b3fecp+107)) (f32.const 0x1.96f37cp+127)) +(assert_return (invoke "f32.add" (f32.const 0x1.132f1cp+118) (f32.const -0x1.63d632p+127)) (f32.const -0x1.634c9ap+127)) +(assert_return (invoke "f32.add" (f32.const -0x1.1dda64p+120) (f32.const -0x1.ef02ep+127)) (f32.const -0x1.f13e94p+127)) +(assert_return (invoke "f32.add" (f32.const -0x1.4ad8dap+127) (f32.const -0x1.eae082p+125)) (f32.const -0x1.c590fap+127)) +(assert_return (invoke "f64.add" (f64.const 0x1.017099f2a4b8bp+1023) (f64.const 0x1.1f63b28f05454p+981)) (f64.const 0x1.017099f2a5009p+1023)) +(assert_return (invoke "f64.add" (f64.const 0x1.d88b6c74984efp+1023) (f64.const 0x1.33b444775eabcp+990)) (f64.const 0x1.d88b6c7532291p+1023)) +(assert_return (invoke "f64.add" (f64.const -0x1.84576422fdf5p+1023) (f64.const 0x1.60ee6aa12fb9cp+1012)) (f64.const -0x1.842b4655a9cf1p+1023)) +(assert_return (invoke "f64.add" (f64.const -0x1.9aaace3e79f7dp+1001) (f64.const 0x1.e4068af295cb6p+1023)) (f64.const 0x1.e4068487ea926p+1023)) +(assert_return (invoke "f64.add" (f64.const 0x1.06cdae79f27b9p+1023) (f64.const -0x1.e05cb0c96f975p+991)) (f64.const 0x1.06cdae78121eep+1023)) + +;; Computations that utilize the minimum exponent value. +(assert_return (invoke "f32.add" (f32.const 0x1.6a1a2p-127) (f32.const 0x1.378p-140)) (f32.const 0x1.6a23dcp-127)) +(assert_return (invoke "f32.add" (f32.const 0x1.28p-144) (f32.const -0x1p-148)) (f32.const 0x1.18p-144)) +(assert_return (invoke "f32.add" (f32.const -0x1p-146) (f32.const 0x1.c3cap-128)) (f32.const 0x1.c3c9cp-128)) +(assert_return (invoke "f32.add" (f32.const -0x1.4p-145) (f32.const 0x1.424052p-122)) (f32.const 0x1.42405p-122)) +(assert_return (invoke "f32.add" (f32.const 0x1.c5p-141) (f32.const -0x1.72f8p-135)) (f32.const -0x1.6be4p-135)) +(assert_return (invoke "f64.add" (f64.const 0x1.4774c681d1e21p-1022) (f64.const -0x1.271e58e9f58cap-1021)) (f64.const -0x1.06c7eb5219373p-1022)) +(assert_return (invoke "f64.add" (f64.const 0x1.10b3a75e31916p-1021) (f64.const -0x1.ffb82b0e868a7p-1021)) (f64.const -0x1.de090760a9f22p-1022)) +(assert_return (invoke "f64.add" (f64.const -0x0.6b58448b8098ap-1022) (f64.const -0x1.579796ed04cbep-1022)) (f64.const -0x1.c2efdb7885648p-1022)) +(assert_return (invoke "f64.add" (f64.const 0x1.9eb9e7baae8d1p-1020) (f64.const -0x1.d58e136f8c6eep-1020)) (f64.const -0x0.db50aed377874p-1022)) +(assert_return (invoke "f64.add" (f64.const -0x1.f1115deeafa0bp-1022) (f64.const 0x1.221b1c87dca29p-1022)) (f64.const -0x0.cef64166d2fe2p-1022)) + +;; Test an add of the second-greatest finite value with the distance to greatest +;; finite value. +(assert_return (invoke "f32.add" (f32.const 0x1.fffffcp+127) (f32.const 0x1p+104)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f64.add" (f64.const 0x1.ffffffffffffep+1023) (f64.const 0x1p+971)) (f64.const 0x1.fffffffffffffp+1023)) + +;; http://news.harvard.edu/gazette/story/2013/09/dawn-of-a-revolution/ +(assert_return (invoke "f32.add" (f32.const 2.0) (f32.const 2.0)) (f32.const 4.0)) +(assert_return (invoke "f64.add" (f64.const 2.0) (f64.const 2.0)) (f64.const 4.0)) + +;; Test rounding above the greatest finite value. +(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const inf)) +(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const inf)) + +;; Test for a historic spreadsheet bug. +;; https://blogs.office.com/2007/09/25/calculation-issue-update/ +(assert_return (invoke "f32.sub" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 65536.0)) +(assert_return (invoke "f64.sub" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1.fffffffffffffp+15)) + +;; Test subtracting the greatest value from 1.0 that rounds back to 1.0, and the +;; least that rounds to something less. +(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1p-25)) (f32.const 0x1.0p+0)) +(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1.000002p-25)) (f32.const 0x1.fffffep-1)) +(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1p-54)) (f64.const 0x1.0p+0)) +(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1.0000000000001p-54)) (f64.const 0x1.fffffffffffffp-1)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.sub" (f32.const 0x1.ee2466p-106) (f32.const -0x1.16277ep+119)) (f32.const 0x1.16277ep+119)) +(assert_return (invoke "f32.sub" (f32.const -0x1.446f9ep+119) (f32.const -0x1.4396a4p+43)) (f32.const -0x1.446f9ep+119)) +(assert_return (invoke "f32.sub" (f32.const 0x1.74773cp+0) (f32.const -0x1.a25512p-82)) (f32.const 0x1.74773cp+0)) +(assert_return (invoke "f32.sub" (f32.const 0x1.9345c4p-117) (f32.const 0x1.6792c2p-76)) (f32.const -0x1.6792c2p-76)) +(assert_return (invoke "f32.sub" (f32.const 0x1.9ecfa4p-18) (f32.const -0x1.864b44p-107)) (f32.const 0x1.9ecfa4p-18)) +(assert_return (invoke "f64.sub" (f64.const -0x1.5b798875e7845p-333) (f64.const -0x1.b5147117452fep-903)) (f64.const -0x1.5b798875e7845p-333)) +(assert_return (invoke "f64.sub" (f64.const -0x1.6c87baeb6d72dp+552) (f64.const -0x1.64fb35d4b5571p-158)) (f64.const -0x1.6c87baeb6d72dp+552)) +(assert_return (invoke "f64.sub" (f64.const 0x1.b3d369fcf74bp-461) (f64.const -0x1.ea1668c0dec93p-837)) (f64.const 0x1.b3d369fcf74bp-461)) +(assert_return (invoke "f64.sub" (f64.const 0x1.0abd449353eadp-1005) (f64.const -0x1.0422ea3e82ee9p+154)) (f64.const 0x1.0422ea3e82ee9p+154)) +(assert_return (invoke "f64.sub" (f64.const -0x1.aadbc6b43cc3dp-143) (f64.const -0x1.e7f922ef1ee58p-539)) (f64.const -0x1.aadbc6b43cc3dp-143)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.sub" (f32.const -0x1.61e262p+108) (f32.const -0x1.baf3e4p+112)) (f32.const 0x1.a4d5bep+112)) +(assert_return (invoke "f32.sub" (f32.const -0x1.62c2f6p+109) (f32.const 0x1.6e514ap+6)) (f32.const -0x1.62c2f6p+109)) +(assert_return (invoke "f32.sub" (f32.const -0x1.287c94p-83) (f32.const 0x1.0f2f9cp-24)) (f32.const -0x1.0f2f9cp-24)) +(assert_return (invoke "f32.sub" (f32.const -0x1.c8825cp-77) (f32.const -0x1.4aead6p-12)) (f32.const 0x1.4aead6p-12)) +(assert_return (invoke "f32.sub" (f32.const -0x1.2976a4p+99) (f32.const 0x1.c6e3b8p-59)) (f32.const -0x1.2976a4p+99)) +(assert_return (invoke "f64.sub" (f64.const -0x1.76cb28ae6c045p+202) (f64.const -0x1.0611f2af4e9b9p+901)) (f64.const 0x1.0611f2af4e9b9p+901)) +(assert_return (invoke "f64.sub" (f64.const 0x1.baf35eff22e9ep-368) (f64.const 0x1.5c3e08ecf73ecp-451)) (f64.const 0x1.baf35eff22e9ep-368)) +(assert_return (invoke "f64.sub" (f64.const -0x1.8fd354b376f1fp-200) (f64.const 0x1.513c860f386ffp-508)) (f64.const -0x1.8fd354b376f1fp-200)) +(assert_return (invoke "f64.sub" (f64.const -0x1.760d447230ae6p-992) (f64.const -0x1.16f788438ae3ep-328)) (f64.const 0x1.16f788438ae3ep-328)) +(assert_return (invoke "f64.sub" (f64.const -0x1.73aab4fcfc7ap+112) (f64.const 0x1.7c589f990b884p+171)) (f64.const -0x1.7c589f990b884p+171)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.sub" (f32.const 0x1.ea264cp+95) (f32.const 0x1.852988p-15)) (f32.const 0x1.ea264cp+95)) +(assert_return (invoke "f32.sub" (f32.const -0x1.14ec7cp+19) (f32.const -0x1.0ad3fep-35)) (f32.const -0x1.14ec7cp+19)) +(assert_return (invoke "f32.sub" (f32.const -0x1.3251dap-36) (f32.const -0x1.49c97ep-56)) (f32.const -0x1.3251c6p-36)) +(assert_return (invoke "f32.sub" (f32.const -0x1.13565ep-14) (f32.const 0x1.2f89a8p-13)) (f32.const -0x1.b934d8p-13)) +(assert_return (invoke "f32.sub" (f32.const -0x1.6032b6p-33) (f32.const -0x1.bb5196p-104)) (f32.const -0x1.6032b6p-33)) +(assert_return (invoke "f64.sub" (f64.const -0x1.b5b0797af491p-157) (f64.const -0x1.694b8348189e8p+722)) (f64.const 0x1.694b8348189e8p+722)) +(assert_return (invoke "f64.sub" (f64.const -0x1.72b142826ed73p+759) (f64.const -0x1.010477bc9afbdp+903)) (f64.const 0x1.010477bc9afbdp+903)) +(assert_return (invoke "f64.sub" (f64.const 0x1.83273b6bb94cfp-796) (f64.const 0x1.1a93f948a2abbp+181)) (f64.const -0x1.1a93f948a2abbp+181)) +(assert_return (invoke "f64.sub" (f64.const -0x1.207e7156cbf2p-573) (f64.const 0x1.cf3f12fd3814dp-544)) (f64.const -0x1.cf3f13063c086p-544)) +(assert_return (invoke "f64.sub" (f64.const -0x1.837e6844f1718p-559) (f64.const -0x1.1c29b757f98abp-14)) (f64.const 0x1.1c29b757f98abp-14)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.sub" (f64.const 0x1.c21151a709b6cp-78) (f64.const 0x1.0a12fff8910f6p-115)) (f64.const 0x1.c21151a701663p-78)) +(assert_return (invoke "f64.sub" (f64.const 0x1.c57912aae2f64p-982) (f64.const 0x1.dbfbd4800b7cfp-1010)) (f64.const 0x1.c579128d2338fp-982)) +(assert_return (invoke "f64.sub" (f64.const 0x1.ffef4399af9c6p-254) (f64.const 0x1.edb96dfaea8b1p-200)) (f64.const -0x1.edb96dfaea8b1p-200)) +(assert_return (invoke "f64.sub" (f64.const -0x1.363eee391cde2p-39) (f64.const -0x1.a65462000265fp-69)) (f64.const -0x1.363eee32838c9p-39)) +(assert_return (invoke "f64.sub" (f64.const 0x1.59016dba002a1p-25) (f64.const 0x1.5d4374f124cccp-3)) (f64.const -0x1.5d436f8d1f15dp-3)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.sub" (f64.const -0x1.18196bca005cfp-814) (f64.const -0x1.db7b01ce3f52fp-766)) (f64.const 0x1.db7b01ce3f51dp-766)) +(assert_return (invoke "f64.sub" (f64.const -0x1.d17b3528d219p+33) (f64.const 0x1.fd739d4ea220ap+367)) (f64.const -0x1.fd739d4ea220ap+367)) +(assert_return (invoke "f64.sub" (f64.const 0x1.dea46994de319p+114) (f64.const 0x1.b5b19cd55c7d3p-590)) (f64.const 0x1.dea46994de319p+114)) +(assert_return (invoke "f64.sub" (f64.const 0x1.b60f9b2fbd9ecp-489) (f64.const -0x1.6f81c59ec5b8ep-694)) (f64.const 0x1.b60f9b2fbd9ecp-489)) +(assert_return (invoke "f64.sub" (f64.const 0x1.5e423fe8571f4p-57) (f64.const 0x1.9624ed7c162dfp-618)) (f64.const 0x1.5e423fe8571f4p-57)) + +;; pow(e, π) - π +;; https://xkcd.com/217/ +(assert_return (invoke "f32.sub" (f32.const 0x1.724046p+4) (f32.const 0x1.921fb6p+1)) (f32.const 0x1.3ffc5p+4)) +(assert_return (invoke "f64.sub" (f64.const 0x1.724046eb0933ap+4) (f64.const 0x1.921fb54442d18p+1)) (f64.const 0x1.3ffc504280d97p+4)) + +;; https://www.cnet.com/news/googles-calculator-muffs-some-math-problems/ +(assert_return (invoke "f32.sub" (f32.const 2999999) (f32.const 2999998)) (f32.const 1.0)) +(assert_return (invoke "f32.sub" (f32.const 1999999) (f32.const 1999995)) (f32.const 4.0)) +(assert_return (invoke "f32.sub" (f32.const 1999999) (f32.const 1999993)) (f32.const 6.0)) +(assert_return (invoke "f32.sub" (f32.const 400002) (f32.const 400001)) (f32.const 1.0)) +(assert_return (invoke "f32.sub" (f32.const 400002) (f32.const 400000)) (f32.const 2.0)) +(assert_return (invoke "f64.sub" (f64.const 2999999999999999) (f64.const 2999999999999998)) (f64.const 1.0)) +(assert_return (invoke "f64.sub" (f64.const 1999999999999999) (f64.const 1999999999999995)) (f64.const 4.0)) +(assert_return (invoke "f64.sub" (f64.const 1999999999999999) (f64.const 1999999999999993)) (f64.const 6.0)) +(assert_return (invoke "f64.sub" (f64.const 400000000000002) (f64.const 400000000000001)) (f64.const 1.0)) +(assert_return (invoke "f64.sub" (f64.const 400000000000002) (f64.const 400000000000000)) (f64.const 2.0)) + +;; Min normal - max subnormal = min subnormal. +(assert_return (invoke "f32.sub" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1p-149)) +(assert_return (invoke "f64.sub" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x0.0000000000001p-1022)) + +;; Test subtraction of numbers very close to 1. +(assert_return (invoke "f32.sub" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.8p-23)) +(assert_return (invoke "f32.sub" (f32.const 0x1.000002p+0) (f32.const 0x1.0p+0)) (f32.const 0x1p-23)) +(assert_return (invoke "f32.sub" (f32.const 0x1p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1p-24)) +(assert_return (invoke "f64.sub" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.8p-52)) +(assert_return (invoke "f64.sub" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.0p+0)) (f64.const 0x1p-52)) +(assert_return (invoke "f64.sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1p-53)) + +;; Test the least value that can be subtracted from the max value to produce a +;; different value. +(assert_return (invoke "f32.sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const 0x1.fffffcp+127)) +(assert_return (invoke "f64.sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64.sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const 0x1.ffffffffffffep+1023)) + +;; Miscellaneous values. +(assert_return (invoke "f32.mul" (f32.const 1e15) (f32.const 1e15)) (f32.const 0x1.93e592p+99)) +(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const inf)) +(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const inf)) +(assert_return (invoke "f64.mul" (f64.const 1e15) (f64.const 1e15)) (f64.const 0x1.93e5939a08ceap+99)) +(assert_return (invoke "f64.mul" (f64.const 1e20) (f64.const 1e20)) (f64.const 0x1.d6329f1c35ca5p+132)) +(assert_return (invoke "f64.mul" (f64.const 1e25) (f64.const 1e25)) (f64.const 0x1.11b0ec57e649bp+166)) + +;; Test for a case of double rounding, example from: +;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html +;; section 3.3.1: A typical problem: "double rounding" +(assert_return (invoke "f32.mul" (f32.const 1848874880.0) (f32.const 19954563072.0)) (f32.const 0x1.000002p+65)) +(assert_return (invoke "f64.mul" (f64.const 1848874847.0) (f64.const 19954562207.0)) (f64.const 3.6893488147419111424e+19)) + +;; Test for a historic spreadsheet bug. +;; http://www.joelonsoftware.com/items/2007/09/26b.html +(assert_return (invoke "f32.mul" (f32.const 77.1) (f32.const 850)) (f32.const 65535)) +(assert_return (invoke "f64.mul" (f64.const 77.1) (f64.const 850)) (f64.const 65534.99999999999272404)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.mul" (f32.const -0x1.14df2ep+61) (f32.const 0x1.748878p-36)) (f32.const -0x1.92e7e8p+25)) +(assert_return (invoke "f32.mul" (f32.const -0x1.5629e2p+102) (f32.const -0x1.c33012p-102)) (f32.const 0x1.2d8604p+1)) +(assert_return (invoke "f32.mul" (f32.const -0x1.b17694p+92) (f32.const -0x1.e4b56ap-97)) (f32.const 0x1.9a5baep-4)) +(assert_return (invoke "f32.mul" (f32.const -0x1.1626a6p+79) (f32.const -0x1.c57d7p-75)) (f32.const 0x1.ecbaaep+4)) +(assert_return (invoke "f32.mul" (f32.const 0x1.7acf72p+53) (f32.const 0x1.6c89acp+5)) (f32.const 0x1.0db556p+59)) +(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -inf)) +(assert_return (invoke "f64.mul" (f64.const -0x1.cc1ae79fffc5bp-986) (f64.const -0x1.c36ccc2861ca6p-219)) (f64.const 0x0p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.c0232b3e64b56p+606) (f64.const -0x1.f6939cf3affaap+106)) (f64.const -0x1.b7e3aedf190d3p+713)) +(assert_return (invoke "f64.mul" (f64.const -0x1.60f289966b271p-313) (f64.const 0x1.28a5497f0c259p+583)) (f64.const -0x1.98fc50bcec259p+270)) +(assert_return (invoke "f64.mul" (f64.const 0x1.37dab12d3afa2p+795) (f64.const 0x1.81e156bd393f1p-858)) (f64.const 0x1.d6126554b8298p-63)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.mul" (f32.const -0x1.3f57a2p-89) (f32.const -0x1.041d68p+92)) (f32.const 0x1.4479bp+3)) +(assert_return (invoke "f32.mul" (f32.const 0x1.4d0582p+73) (f32.const 0x1.6e043ap+19)) (f32.const 0x1.dc236p+92)) +(assert_return (invoke "f32.mul" (f32.const -0x1.2fdap-32) (f32.const -0x1.e1731cp+74)) (f32.const 0x1.1db89ep+43)) +(assert_return (invoke "f32.mul" (f32.const 0x1.7bc8fep+67) (f32.const -0x1.3ad592p+15)) (f32.const -0x1.d3115ep+82)) +(assert_return (invoke "f32.mul" (f32.const 0x1.936742p+30) (f32.const -0x1.a7a19p+66)) (f32.const -0x1.4dc71ap+97)) +(assert_return (invoke "f64.mul" (f64.const -0x1.ba737b4ca3b13p-639) (f64.const 0x1.8923309857438p-314)) (f64.const -0x1.53bc0d07baa37p-952)) +(assert_return (invoke "f64.mul" (f64.const 0x1.7c1932e610219p-276) (f64.const -0x1.2605db646489fp-635)) (f64.const -0x1.b48da2b0d2ae3p-911)) +(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const inf)) +(assert_return (invoke "f64.mul" (f64.const 0x1.4c19466551da3p+947) (f64.const 0x1.0bdcd6c7646e9p-439)) (f64.const 0x1.5b7cd8c3f638ap+508)) +(assert_return (invoke "f64.mul" (f64.const 0x1.ff1da1726e3dfp+339) (f64.const -0x1.043c44f52b158p+169)) (f64.const -0x1.03c9364bb585cp+509)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const inf)) +(assert_return (invoke "f32.mul" (f32.const -0x1.8c9f74p-3) (f32.const 0x1.e2b452p-99)) (f32.const -0x1.75edccp-101)) +(assert_return (invoke "f32.mul" (f32.const -0x1.cc605ap-19) (f32.const 0x1.ec321ap+105)) (f32.const -0x1.ba91a4p+87)) +(assert_return (invoke "f32.mul" (f32.const -0x1.5fbb7ap+56) (f32.const 0x1.a8965ep-96)) (f32.const -0x1.23ae8ep-39)) +(assert_return (invoke "f32.mul" (f32.const -0x1.fb7f12p+16) (f32.const 0x1.3a701ap-119)) (f32.const -0x1.37ac0cp-102)) +(assert_return (invoke "f64.mul" (f64.const -0x1.5b0266454c26bp-496) (f64.const -0x1.af5787e3e0399p+433)) (f64.const 0x1.2457d81949e0bp-62)) +(assert_return (invoke "f64.mul" (f64.const 0x1.0d54a82393d45p+478) (f64.const -0x1.425760807ceaep-764)) (f64.const -0x1.532068c8d0d5dp-286)) +(assert_return (invoke "f64.mul" (f64.const -0x1.b532af981786p+172) (f64.const 0x1.ada95085ba36fp+359)) (f64.const -0x1.6ee38c1e01864p+532)) +(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -inf)) +(assert_return (invoke "f64.mul" (f64.const 0x1.68bbf1cfff90ap+81) (f64.const 0x1.09cd17d652c5p+70)) (f64.const 0x1.768b8d67d794p+151)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.mul" (f64.const 0x1.f99fb602c89b7p-341) (f64.const 0x1.6caab46a31a2ep-575)) (f64.const 0x1.68201f986e9d7p-915)) +(assert_return (invoke "f64.mul" (f64.const -0x1.86999c5eee379p-9) (f64.const 0x1.6e3b9e0d53e0dp+723)) (f64.const -0x1.17654a0ef35f5p+715)) +(assert_return (invoke "f64.mul" (f64.const -0x1.069571b176f9p+367) (f64.const -0x1.e248b6ab0a0e3p-652)) (f64.const 0x1.eeaff575cae1dp-285)) +(assert_return (invoke "f64.mul" (f64.const 0x1.c217645777dd2p+775) (f64.const 0x1.d93f5715dd646p+60)) (f64.const 0x1.a0064aa1d920dp+836)) +(assert_return (invoke "f64.mul" (f64.const -0x1.848981b6e694ap-276) (f64.const 0x1.f5aacb64a0d19p+896)) (f64.const -0x1.7cb2296e6c2e5p+621)) + +;; Computations that round differently on x87 in double-precision mode. +(assert_return (invoke "f64.mul" (f64.const 0x1.db3bd2a286944p-599) (f64.const 0x1.ce910af1d55cap-425)) (f64.const 0x0.d6accdd538a39p-1022)) +(assert_return (invoke "f64.mul" (f64.const -0x1.aca223916012p-57) (f64.const -0x1.2b2b4958dd228p-966)) (f64.const 0x0.fa74eccae5615p-1022)) +(assert_return (invoke "f64.mul" (f64.const -0x1.bd062def16cffp-488) (f64.const -0x1.7ddd91a0c4c0ep-536)) (f64.const 0x0.a5f4d7769d90dp-1022)) +(assert_return (invoke "f64.mul" (f64.const -0x1.c6a56169e9cep-772) (f64.const 0x1.517d55a474122p-255)) (f64.const -0x0.12baf260afb77p-1022)) +(assert_return (invoke "f64.mul" (f64.const -0x1.08951b0b41705p-516) (f64.const -0x1.102dc27168d09p-507)) (f64.const 0x0.8ca6dbf3f592bp-1022)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.mul" (f64.const 0x1.8d0dea50c8c9bp+852) (f64.const 0x1.21cac31d87a24p-881)) (f64.const 0x1.c177311f7cd73p-29)) +(assert_return (invoke "f64.mul" (f64.const 0x1.98049118e3063p-7) (f64.const 0x1.6362525151b58p-149)) (f64.const 0x1.1b358514103f9p-155)) +(assert_return (invoke "f64.mul" (f64.const -0x1.ea65cb0631323p+1) (f64.const 0x1.fce683201a19bp-41)) (f64.const -0x1.e76dc8c223667p-39)) +(assert_return (invoke "f64.mul" (f64.const 0x1.e4d235961d543p-373) (f64.const 0x1.bc56f20ef9a48p-205)) (f64.const 0x1.a4c09efcb71d6p-577)) +(assert_return (invoke "f64.mul" (f64.const -0x1.b9612e66faba8p+77) (f64.const 0x1.e2bc6aa782273p-348)) (f64.const -0x1.a026ea4f81db1p-270)) + +;; Test the least positive value with a positive square. +(assert_return (invoke "f32.mul" (f32.const 0x1p-75) (f32.const 0x1p-75)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.mul" (f32.const 0x1.000002p-75) (f32.const 0x1.000002p-75)) (f32.const 0x1p-149)) +(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bccp-538) (f64.const 0x1.6a09e667f3bccp-538)) (f64.const 0x0p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bcdp-538) (f64.const 0x1.6a09e667f3bcdp-538)) (f64.const 0x0.0000000000001p-1022)) + +;; Test the greatest positive value with a finite square. +(assert_return (invoke "f32.mul" (f32.const 0x1.fffffep+63) (f32.const 0x1.fffffep+63)) (f32.const 0x1.fffffcp+127)) +(assert_return (invoke "f32.mul" (f32.const 0x1p+64) (f32.const 0x1p+64)) (f32.const inf)) +(assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp+511) (f64.const 0x1.fffffffffffffp+511)) (f64.const 0x1.ffffffffffffep+1023)) +(assert_return (invoke "f64.mul" (f64.const 0x1p+512) (f64.const 0x1p+512)) (f64.const inf)) + +;; Test the squares of values very close to 1. +(assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.000004p+0)) +(assert_return (invoke "f32.mul" (f32.const 0x1.fffffep-1) (f32.const 0x1.fffffep-1)) (f32.const 0x1.fffffcp-1)) +(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.0000000000002p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.ffffffffffffep-1)) + +;; Test multiplication of numbers very close to 1. +(assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1p+0)) +(assert_return (invoke "f32.mul" (f32.const 0x1.000004p+0) (f32.const 0x1.fffffcp-1)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000002p+0) (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.0000000000001p+0)) + +;; Test MIN * EPSILON. +;; http://www.mpfr.org/mpfr-2.0.1/patch2 +(assert_return (invoke "f32.mul" (f32.const 0x1p-126) (f32.const 0x1p-23)) (f32.const 0x1p-149)) +(assert_return (invoke "f64.mul" (f64.const 0x1p-1022) (f64.const 0x1p-52)) (f64.const 0x0.0000000000001p-1022)) + +;; http://opencores.org/bug,view,2454 +(assert_return (invoke "f32.mul" (f32.const -0x1.0006p+4) (f32.const 0x1.ap-132)) (f32.const -0x1.a009cp-128)) + +;; Miscellaneous values. +(assert_return (invoke "f32.div" (f32.const 1.123456789) (f32.const 100)) (f32.const 0x1.702264p-7)) +(assert_return (invoke "f32.div" (f32.const 8391667.0) (f32.const 12582905.0)) (f32.const 0x1.55754p-1)) +(assert_return (invoke "f32.div" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 0x1p+53)) +(assert_return (invoke "f32.div" (f32.const 0x1.dcbf6ap+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.dcbf68p-128)) +(assert_return (invoke "f32.div" (f32.const 4) (f32.const 3)) (f32.const 0x1.555556p+0)) +(assert_return (invoke "f64.div" (f64.const 1.123456789) (f64.const 100)) (f64.const 0.01123456789)) +(assert_return (invoke "f64.div" (f64.const 8391667.0) (f64.const 12582905.0)) (f64.const 0x1.55753f1d9ba27p-1)) +(assert_return (invoke "f64.div" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1p+53)) +(assert_return (invoke "f64.div" (f64.const 0x1.dcbf6ap+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda8p-1022)) +(assert_return (invoke "f64.div" (f64.const 4) (f64.const 3)) (f64.const 0x1.5555555555555p+0)) + +;; Test for a historic hardware bug. +;; https://en.wikipedia.org/wiki/Pentium_FDIV_bug +(assert_return (invoke "f32.div" (f32.const 4195835) (f32.const 3145727)) (f32.const 0x1.557542p+0)) +(assert_return (invoke "f64.div" (f64.const 4195835) (f64.const 3145727)) (f64.const 0x1.557541c7c6b43p+0)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.div" (f32.const 0x1.6a6c5ap-48) (f32.const 0x1.fa0b7p+127)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1.616fb2p-87) (f32.const 0x1.332172p+68)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.div" (f32.const -0x1.96e778p+16) (f32.const 0x1.eb0c56p-80)) (f32.const -0x1.a8440ap+95)) +(assert_return (invoke "f32.div" (f32.const -0x1.e2624p-76) (f32.const -0x1.ed236ep-122)) (f32.const 0x1.f4d584p+45)) +(assert_return (invoke "f32.div" (f32.const -0x1.e2374ep+41) (f32.const 0x1.71fcdcp-80)) (f32.const -0x1.4da706p+121)) +(assert_return (invoke "f64.div" (f64.const 0x1.163c09d0c38c1p+147) (f64.const 0x1.e04cc737348e6p+223)) (f64.const 0x1.289921caeed23p-77)) +(assert_return (invoke "f64.div" (f64.const 0x1.d6867e741e0a9p-626) (f64.const 0x1.335eb19a9aae4p-972)) (f64.const 0x1.87e342d11f519p+346)) +(assert_return (invoke "f64.div" (f64.const -0x1.d5edf648aeb98p+298) (f64.const 0x1.0dda15b079355p+640)) (f64.const -0x1.bdceaf9734b5cp-342)) +(assert_return (invoke "f64.div" (f64.const -0x1.b683e3934aedap+691) (f64.const 0x1.c364e1df00dffp+246)) (f64.const -0x1.f16456e7afe3bp+444)) +(assert_return (invoke "f64.div" (f64.const -0x1.44ca7539cc851p+540) (f64.const 0x1.58501bccc58fep+453)) (f64.const -0x1.e2f8657e0924ep+86)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const inf)) +(assert_return (invoke "f32.div" (f32.const 0x1.e35abep-46) (f32.const 0x1.c69dfp+44)) (f32.const 0x1.102eb4p-90)) +(assert_return (invoke "f32.div" (f32.const 0x1.45ff2ap+0) (f32.const -0x1.1e8754p+89)) (f32.const -0x1.23434ep-89)) +(assert_return (invoke "f32.div" (f32.const 0x1.8db18ap-51) (f32.const 0x1.47c678p-128)) (f32.const 0x1.369b96p+77)) +(assert_return (invoke "f32.div" (f32.const 0x1.78599p+90) (f32.const 0x1.534144p+87)) (f32.const 0x1.1bfddcp+3)) +(assert_return (invoke "f64.div" (f64.const 0x0.f331c4f47eb51p-1022) (f64.const -0x1.c7ff45bf6f03ap+362)) (f64.const -0x0p+0)) +(assert_return (invoke "f64.div" (f64.const -0x1.0fc8707b9d19cp-987) (f64.const 0x1.77524d5f4a563p-536)) (f64.const -0x1.72c1a937d231p-452)) +(assert_return (invoke "f64.div" (f64.const -0x1.edb3aa64bb338p-403) (f64.const -0x1.1c7c164320e4p+45)) (f64.const 0x1.bc44cc1c5ae63p-448)) +(assert_return (invoke "f64.div" (f64.const -0x1.6534b34e8686bp+80) (f64.const 0x1.c34a7fc59e3c3p-791)) (f64.const -0x1.95421bf291b66p+870)) +(assert_return (invoke "f64.div" (f64.const -0x1.91f58d7ed1237p+236) (f64.const -0x1.f190d808383c8p+55)) (f64.const 0x1.9d9eb0836f906p+180)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const inf)) +(assert_return (invoke "f32.div" (f32.const -0x1.53c9b6p+77) (f32.const 0x1.d689ap+27)) (f32.const -0x1.71baa4p+49)) +(assert_return (invoke "f32.div" (f32.const 0x1.664a8ap+38) (f32.const -0x1.59dba2p+96)) (f32.const -0x1.0933f4p-58)) +(assert_return (invoke "f32.div" (f32.const -0x1.99e0fap+111) (f32.const -0x1.c2b5a8p+9)) (f32.const 0x1.d19de6p+101)) +(assert_return (invoke "f32.div" (f32.const -0x1.5a815ap+92) (f32.const -0x1.b5820ap+13)) (f32.const 0x1.9580b8p+78)) +(assert_return (invoke "f64.div" (f64.const -0x1.81fd1e2af7bebp-655) (f64.const 0x1.edefc4eae536cp-691)) (f64.const -0x1.901abdd91b661p+35)) +(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const inf)) +(assert_return (invoke "f64.div" (f64.const -0x1.2bd2e8fbdcad7p-746) (f64.const 0x1.b115674cc476ep-65)) (f64.const -0x1.62752bf19fa81p-682)) +(assert_return (invoke "f64.div" (f64.const -0x1.f923e3fea9efep+317) (f64.const -0x1.8044c74d27a39p-588)) (f64.const 0x1.5086518cc7186p+905)) +(assert_return (invoke "f64.div" (f64.const 0x1.516ed2051d6bbp+181) (f64.const -0x1.c9f455eb9c2eep+214)) (f64.const -0x1.79414d67f2889p-34)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.div" (f64.const -0x1.9c52726aed366p+585) (f64.const -0x1.7d0568c75660fp+195)) (f64.const 0x1.1507ca2a65f23p+390)) +(assert_return (invoke "f64.div" (f64.const -0x1.522672f461667p+546) (f64.const -0x1.36d36572c9f71p+330)) (f64.const 0x1.1681369370619p+216)) +(assert_return (invoke "f64.div" (f64.const 0x1.01051b4e8cd61p+185) (f64.const -0x1.2cbb5ca3d33ebp+965)) (f64.const -0x1.b59471598a2f3p-781)) +(assert_return (invoke "f64.div" (f64.const 0x1.5f93bb80fc2cbp+217) (f64.const 0x1.7e051aae9f0edp+427)) (f64.const 0x1.d732fa926ba4fp-211)) +(assert_return (invoke "f64.div" (f64.const -0x1.e251d762163ccp+825) (f64.const 0x1.3ee63581e1796p+349)) (f64.const -0x1.8330077d90a07p+476)) + +;; Computations that round differently on x87 in double-precision mode. +(assert_return (invoke "f64.div" (f64.const 0x1.dcbf69f10006dp+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda7c4001bp-1022)) +(assert_return (invoke "f64.div" (f64.const 0x1.e14169442fbcap-1011) (f64.const 0x1.505451d62ff7dp+12)) (f64.const 0x0.b727e85f38b39p-1022)) +(assert_return (invoke "f64.div" (f64.const -0x1.d3ebe726ec964p-144) (f64.const -0x1.4a7bfc0b83608p+880)) (f64.const 0x0.5a9d8c50cbf87p-1022)) +(assert_return (invoke "f64.div" (f64.const -0x1.6c3def770aee1p-393) (f64.const -0x1.8b84724347598p+631)) (f64.const 0x0.3af0707fcd0c7p-1022)) +(assert_return (invoke "f64.div" (f64.const 0x1.16abda1bb3cb3p-856) (f64.const 0x1.6c9c7198eb1e6p+166)) (f64.const 0x0.c3a8fd6741649p-1022)) +(assert_return (invoke "f64.div" (f64.const 0x1.7057d6ab553cap-1005) (f64.const -0x1.2abf1e98660ebp+23)) (f64.const -0x0.04ee8d8ec01cdp-1022)) + +;; Computations that round differently when div is mul by reciprocal. +(assert_return (invoke "f32.div" (f32.const 0x1.ada9aap+89) (f32.const 0x1.69884cp+42)) (f32.const 0x1.303e2ep+47)) +(assert_return (invoke "f32.div" (f32.const 0x1.8281c8p+90) (f32.const -0x1.62883cp+106)) (f32.const -0x1.17169cp-16)) +(assert_return (invoke "f32.div" (f32.const 0x1.5c6be2p+81) (f32.const 0x1.d01dfep-1)) (f32.const 0x1.805e32p+81)) +(assert_return (invoke "f32.div" (f32.const -0x1.bbd252p+19) (f32.const -0x1.fba95p+33)) (f32.const 0x1.bf9d56p-15)) +(assert_return (invoke "f32.div" (f32.const -0x1.0f41d6p-42) (f32.const -0x1.3f2dbep+56)) (f32.const 0x1.b320d8p-99)) +(assert_return (invoke "f64.div" (f64.const 0x1.b2348a1c81899p+61) (f64.const -0x1.4a58aad903dd3p-861)) (f64.const -0x1.507c1e2a41b35p+922)) +(assert_return (invoke "f64.div" (f64.const 0x1.23fa5137a918ap-130) (f64.const -0x1.7268db1951263p-521)) (f64.const -0x1.93965e0d896bep+390)) +(assert_return (invoke "f64.div" (f64.const 0x1.dcb3915d82deep+669) (f64.const 0x1.50caaa1dc6b19p+638)) (f64.const 0x1.6a58ec814b09dp+31)) +(assert_return (invoke "f64.div" (f64.const -0x1.046e378c0cc46p+182) (f64.const 0x1.ac925009a922bp+773)) (f64.const -0x1.3720aa94dab18p-592)) +(assert_return (invoke "f64.div" (f64.const -0x1.8945fd69d8e11p-871) (f64.const -0x1.0a37870af809ap-646)) (f64.const 0x1.7a2e286c62382p-225)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.div" (f64.const 0x1.82002af0ea1f3p-57) (f64.const 0x1.d0a9b0c2fa339p+0)) (f64.const 0x1.a952fbd1fc17cp-58)) +(assert_return (invoke "f64.div" (f64.const 0x1.1e12b515db471p-102) (f64.const -0x1.41fc3c94fba5p-42)) (f64.const -0x1.c6e50cccb7cb6p-61)) +(assert_return (invoke "f64.div" (f64.const 0x1.aba5adcd6f583p-41) (f64.const 0x1.17dfac639ce0fp-112)) (f64.const 0x1.872b0a008c326p+71)) +(assert_return (invoke "f64.div" (f64.const 0x1.cf82510d0ae6bp+89) (f64.const 0x1.0207d86498053p+97)) (f64.const 0x1.cbdc804e2cf14p-8)) +(assert_return (invoke "f64.div" (f64.const 0x1.4c82cbb508e21p-11) (f64.const -0x1.6b57208c2d5d5p+52)) (f64.const -0x1.d48e8b369129ap-64)) + +;; Division involving the maximum subnormal value and the minimum normal value. +(assert_return (invoke "f32.div" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1.fffffcp-127) (f32.const 0x1p-126)) (f32.const 0x1.fffffcp-1)) +(assert_return (invoke "f64.div" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1.0000000000001p+0)) +(assert_return (invoke "f64.div" (f64.const 0x0.fffffffffffffp-1022) (f64.const 0x1p-1022)) (f64.const 0x1.ffffffffffffep-1)) + +;; Test the least positive value with a positive quotient with the maximum value. +(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-23) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1p-22) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149)) +(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-52) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "f64.div" (f64.const 0x1p-51) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) + +;; Test the least positive value with a finite reciprocal. +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const inf)) +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000008p-128)) (f32.const 0x1.fffffp+127)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const inf)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4000000000001p-1022)) (f64.const 0x1.ffffffffffff8p+1023)) + +;; Test the least positive value that has a subnormal reciprocal. +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000002p+126)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p+126)) (f32.const 0x1p-126)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x1.0000000000001p+1022)) (f64.const 0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x1p+1022)) (f64.const 0x1p-1022)) + +;; Test that the last binary digit of 1.0/3.0 is even in f32, +;; https://en.wikipedia.org/wiki/Single-precision_floating-point_format#Single-precision_examples +;; +;; and odd in f64, +;; https://en.wikipedia.org/wiki/Double-precision_floating-point_format#Double-precision_examples +;; +;; and that 1.0/3.0, 3.0/9.0, and 9.0/27.0 all agree. +;; http://www.netlib.org/paranoia +(assert_return (invoke "f32.div" (f32.const 0x1p+0) (f32.const 0x1.8p+1)) (f32.const 0x1.555556p-2)) +(assert_return (invoke "f32.div" (f32.const 0x3p+0) (f32.const 0x1.2p+3)) (f32.const 0x1.555556p-2)) +(assert_return (invoke "f32.div" (f32.const 0x1.2p+3) (f32.const 0x1.bp+4)) (f32.const 0x1.555556p-2)) +(assert_return (invoke "f64.div" (f64.const 0x1p+0) (f64.const 0x1.8p+1)) (f64.const 0x1.5555555555555p-2)) +(assert_return (invoke "f64.div" (f64.const 0x3p+0) (f64.const 0x1.2p+3)) (f64.const 0x1.5555555555555p-2)) +(assert_return (invoke "f64.div" (f64.const 0x1.2p+3) (f64.const 0x1.bp+4)) (f64.const 0x1.5555555555555p-2)) + +;; Test division of numbers very close to 1. +(assert_return (invoke "f32.div" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.000004p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-1) (f32.const 0x1.000002p+0)) (f32.const 0x1.fffffap-1)) +(assert_return (invoke "f32.div" (f32.const 0x1.0p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1.0p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.fffffcp-1)) +(assert_return (invoke "f64.div" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.0000000000002p+0)) +(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.ffffffffffffdp-1)) +(assert_return (invoke "f64.div" (f64.const 0x1.0p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.0000000000001p+0)) +(assert_return (invoke "f64.div" (f64.const 0x1.0p+0) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.ffffffffffffep-1)) + +;; Test for bugs found in an early RISC-V implementation. +;; https://github.com/riscv/riscv-tests/pull/8 +(assert_return (invoke "f32.sqrt" (f32.const 0x1.56p+7)) (f32.const 0x1.a2744cp+3)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.594dfcp-23)) (f32.const 0x1.a4789cp-12)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.56p+7)) (f64.const 0x1.a2744ce9674f5p+3)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.594dfc70aa105p-23)) (f64.const 0x1.a4789c0e37f99p-12)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.sqrt" (f64.const 0x1.0263fcc94f259p-164)) (f64.const 0x1.0131485de579fp-82)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.352dfa278c43dp+338)) (f64.const 0x1.195607dac5417p+169)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.b15daa23924fap+402)) (f64.const 0x1.4d143db561493p+201)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.518c8e68cb753p-37)) (f64.const 0x1.9fb8ef1ad5bfdp-19)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.86d8b6518078ep-370)) (f64.const 0x1.3c5142a48fcadp-185)) + +;; Test another sqrt case on x87. +;; https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52593 +(assert_return (invoke "f64.sqrt" (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.fffffffffffffp-1)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.098064p-3)) (f32.const 0x1.70b23p-2)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.d9befp+100)) (f32.const 0x1.5c4052p+50)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.42b5b6p-4)) (f32.const 0x1.1f6d0ep-2)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.3684dp-71)) (f32.const 0x1.8ebae2p-36)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.d8bc4ep-11)) (f32.const 0x1.ebf9eap-6)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.5c39f220d5704p-924)) (f64.const 0x1.2a92bc24ceae9p-462)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.53521a635745cp+727)) (f64.const 0x1.a0cfdc4ef8ff1p+363)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.dfd5bbc9f4678p+385)) (f64.const 0x1.efa817117c94cp+192)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.33f9640811cd4p+105)) (f64.const 0x1.8d17c9243baa3p+52)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.6c0ef0267ff45p+999)) (f64.const 0x1.afbcfae3f2b4p+499)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.26a62ep+27)) (f32.const 0x1.84685p+13)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.166002p-113)) (f32.const 0x1.798762p-57)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.3dfb5p-15)) (f32.const 0x1.937e38p-8)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.30eb2cp-120)) (f32.const 0x1.176406p-60)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.cb705cp-123)) (f32.const 0x1.e5020ap-62)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.edae8aea0543p+695)) (f64.const 0x1.f6c1ea4fc8dd2p+347)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.f7ee4bda5c9c3p-763)) (f64.const 0x1.fbf30bdaf11c5p-382)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.a48f348266ad1p-30)) (f64.const 0x1.481ee7540baf7p-15)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.feb5a1ce3ed9cp-242)) (f64.const 0x1.6995060c20d46p-121)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.957d9796e3834p+930)) (f64.const 0x1.42305213157bap+465)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.65787cp+118)) (f32.const 0x1.2e82a4p+59)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.736044p+15)) (f32.const 0x1.b40e4p+7)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.a00edp-1)) (f32.const 0x1.cd8aecp-1)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.7a4c8p-87)) (f32.const 0x1.b819e4p-44)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.5d24d4p-94)) (f32.const 0x1.2af75ep-47)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.a008948ead274p+738)) (f64.const 0x1.4659b37c39b19p+369)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.70f6199ed21f5p-381)) (f64.const 0x1.b2a2bddf3300dp-191)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.35c1d49f2a352p+965)) (f64.const 0x1.8e3d9f01a9716p+482)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.3fbdcfb2b2a15p-45)) (f64.const 0x1.949ba4feca42ap-23)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.c201b94757145p-492)) (f64.const 0x1.5369ee6bf2967p-246)) + +;; Computations that round differently when computed via f32. +(assert_return_canonical_nan (invoke "f64.sqrt" (f64.const -0x1.360e8d0032adp-963))) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.d9a6f5eef0503p+103)) (f64.const 0x1.ec73f56c166f6p+51)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.aa051a5c4ec27p-760)) (f64.const 0x1.4a3e771ff5149p-380)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.e5522a741babep-276)) (f64.const 0x1.607ae2b6feb7dp-138)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.4832badc0c061p+567)) (f64.const 0x1.99ec7934139b2p+283)) + +;; Test the least value with a sqrt that rounds to one. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.000002p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.000004p+0)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000001p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000002p+0)) (f64.const 0x1.0000000000001p+0)) + +;; Test the greatest value less than one for which sqrt is not an identity. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffcp-1)) (f32.const 0x1.fffffep-1)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffap-1)) (f32.const 0x1.fffffcp-1)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.fffffffffffffp-1)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffdp-1)) (f64.const 0x1.ffffffffffffep-1)) + +;; Test that the bitwise floating point operators are bitwise on NaN. + +(assert_return (invoke "f32.abs" (f32.const nan:0x0f1e2)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f32.abs" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f64.abs" (f64.const nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b)) +(assert_return (invoke "f64.abs" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b)) + +(assert_return (invoke "f32.neg" (f32.const nan:0x0f1e2)) (f32.const -nan:0x0f1e2)) +(assert_return (invoke "f32.neg" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f64.neg" (f64.const nan:0x0f1e27a6b)) (f64.const -nan:0x0f1e27a6b)) +(assert_return (invoke "f64.neg" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b)) + +(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2)) +(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2)) +(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b)) +(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b)) +(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b)) +(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b)) + +;; Test values close to 1.0. +(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep-1)) (f32.const 1.0)) +(assert_return (invoke "f32.ceil" (f32.const 0x1.000002p+0)) (f32.const 2.0)) +(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp-1)) (f64.const 1.0)) +(assert_return (invoke "f64.ceil" (f64.const 0x1.0000000000001p+0)) (f64.const 2.0)) + +;; Test the maximum and minimum value for which ceil is not an identity operator. +(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+22)) (f32.const 0x1p+23)) +(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22)) +(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52)) +(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51)) + +;; Test that implementations don't do the x+0x1p52-0x1p52 trick outside the +;; range where it's safe. +(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+23)) (f32.const 0x1.fffffep+23)) +(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+23)) (f32.const -0x1.fffffep+23)) +(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+52)) (f64.const 0x1.fffffffffffffp+52)) +(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+52)) (f64.const -0x1.fffffffffffffp+52)) + +;; Test values close to -1.0. +(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep-1)) (f32.const -1.0)) +(assert_return (invoke "f32.floor" (f32.const -0x1.000002p+0)) (f32.const -2.0)) +(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp-1)) (f64.const -1.0)) +(assert_return (invoke "f64.floor" (f64.const -0x1.0000000000001p+0)) (f64.const -2.0)) + +;; Test the maximum and minimum value for which floor is not an identity operator. +(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep+22)) (f32.const -0x1p+23)) +(assert_return (invoke "f32.floor" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22)) +(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52)) +(assert_return (invoke "f64.floor" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51)) + +;; Test that floor isn't implemented as XMVectorFloor. +;; http://dss.stephanierct.com/DevBlog/?p=8#comment-4 +(assert_return (invoke "f32.floor" (f32.const 88607.0)) (f32.const 88607.0)) +(assert_return (invoke "f64.floor" (f64.const 88607.0)) (f64.const 88607.0)) + +;; Test the maximum and minimum value for which trunc is not an identity operator. +(assert_return (invoke "f32.trunc" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22)) +(assert_return (invoke "f32.trunc" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22)) +(assert_return (invoke "f64.trunc" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51)) +(assert_return (invoke "f64.trunc" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51)) + +;; Test that nearest isn't implemented naively. +;; http://blog.frama-c.com/index.php?post/2013/05/02/nearbyintf1 +;; http://blog.frama-c.com/index.php?post/2013/05/04/nearbyintf3 +(assert_return (invoke "f32.nearest" (f32.const 0x1.000002p+23)) (f32.const 0x1.000002p+23)) +(assert_return (invoke "f32.nearest" (f32.const 0x1.000004p+23)) (f32.const 0x1.000004p+23)) +(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep-2)) (f32.const 0.0)) +(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep+47)) (f32.const 0x1.fffffep+47)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000001p+52)) (f64.const 0x1.0000000000001p+52)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000002p+52)) (f64.const 0x1.0000000000002p+52)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp-2)) (f64.const 0.0)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp+105)) (f64.const 0x1.fffffffffffffp+105)) + +;; Nearest should not round halfway cases away from zero (as C's round(3) does) +;; or up (as JS's Math.round does). +(assert_return (invoke "f32.nearest" (f32.const 4.5)) (f32.const 4.0)) +(assert_return (invoke "f32.nearest" (f32.const -4.5)) (f32.const -4.0)) +(assert_return (invoke "f32.nearest" (f32.const -3.5)) (f32.const -4.0)) +(assert_return (invoke "f64.nearest" (f64.const 4.5)) (f64.const 4.0)) +(assert_return (invoke "f64.nearest" (f64.const -4.5)) (f64.const -4.0)) +(assert_return (invoke "f64.nearest" (f64.const -3.5)) (f64.const -4.0)) + +;; Test the maximum and minimum value for which nearest is not an identity operator. +(assert_return (invoke "f32.nearest" (f32.const -0x1.fffffep+22)) (f32.const -0x1p+23)) +(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep+22)) (f32.const 0x1p+23)) +(assert_return (invoke "f64.nearest" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52)) diff --git a/src/build_spectests.rs b/src/build_spectests.rs index 84ab31d8b..cde75ac2e 100644 --- a/src/build_spectests.rs +++ b/src/build_spectests.rs @@ -15,7 +15,7 @@ static ENV_VAR: &str = "WASM_GENERATE_SPECTESTS"; static BANNER: &str = "// Rust test file autogenerated with cargo build (src/build_spectests.rs). // Please do NOT modify it by hand, as it will be reseted on next build.\n"; -const TESTS: [&str; 47] = [ +const TESTS: [&str; 48] = [ "spectests/address.wast", "spectests/align.wast", "spectests/binary.wast", @@ -43,6 +43,7 @@ const TESTS: [&str; 47] = [ "spectests/float_exprs.wast", "spectests/float_literals.wast", "spectests/float_memory.wast", + "spectests/float_misc.wast", "spectests/func.wast", "spectests/func_ptrs.wast", "spectests/get_local.wast", diff --git a/src/spectests/float_misc.rs b/src/spectests/float_misc.rs new file mode 100644 index 000000000..b09e314e4 --- /dev/null +++ b/src/spectests/float_misc.rs @@ -0,0 +1,5885 @@ +// Rust test file autogenerated with cargo build (src/build_spectests.rs). +// Please do NOT modify it by hand, as it will be reseted on next build. +// Test based on spectests/float_misc.wast +#![allow( + warnings, + dead_code +)] +use crate::webassembly::{instantiate, compile, ImportObject, ResultObject, VmCtx, Export}; +use super::_common::spectest_importobject; +use wabt::wat2wasm; + + +// Line 17 +fn create_module_1() -> ResultObject { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f32) (result f32))) + (type (;2;) (func (param f64 f64) (result f64))) + (type (;3;) (func (param f64) (result f64))) + (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 1) (param f32) (result f32) + get_local 0 + f32.abs) + (func (;6;) (type 1) (param f32) (result f32) + get_local 0 + f32.neg) + (func (;7;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.copysign) + (func (;8;) (type 1) (param f32) (result f32) + get_local 0 + f32.ceil) + (func (;9;) (type 1) (param f32) (result f32) + get_local 0 + f32.floor) + (func (;10;) (type 1) (param f32) (result f32) + get_local 0 + f32.trunc) + (func (;11;) (type 1) (param f32) (result f32) + get_local 0 + f32.nearest) + (func (;12;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.min) + (func (;13;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.max) + (func (;14;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.add) + (func (;15;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.sub) + (func (;16;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul) + (func (;17;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.div) + (func (;18;) (type 3) (param f64) (result f64) + get_local 0 + f64.sqrt) + (func (;19;) (type 3) (param f64) (result f64) + get_local 0 + f64.abs) + (func (;20;) (type 3) (param f64) (result f64) + get_local 0 + f64.neg) + (func (;21;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.copysign) + (func (;22;) (type 3) (param f64) (result f64) + get_local 0 + f64.ceil) + (func (;23;) (type 3) (param f64) (result f64) + get_local 0 + f64.floor) + (func (;24;) (type 3) (param f64) (result f64) + get_local 0 + f64.trunc) + (func (;25;) (type 3) (param f64) (result f64) + get_local 0 + f64.nearest) + (func (;26;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.min) + (func (;27;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.max) + (export \"f32.add\" (func 0)) + (export \"f32.sub\" (func 1)) + (export \"f32.mul\" (func 2)) + (export \"f32.div\" (func 3)) + (export \"f32.sqrt\" (func 4)) + (export \"f32.abs\" (func 5)) + (export \"f32.neg\" (func 6)) + (export \"f32.copysign\" (func 7)) + (export \"f32.ceil\" (func 8)) + (export \"f32.floor\" (func 9)) + (export \"f32.trunc\" (func 10)) + (export \"f32.nearest\" (func 11)) + (export \"f32.min\" (func 12)) + (export \"f32.max\" (func 13)) + (export \"f64.add\" (func 14)) + (export \"f64.sub\" (func 15)) + (export \"f64.mul\" (func 16)) + (export \"f64.div\" (func 17)) + (export \"f64.sqrt\" (func 18)) + (export \"f64.abs\" (func 19)) + (export \"f64.neg\" (func 20)) + (export \"f64.copysign\" (func 21)) + (export \"f64.ceil\" (func 22)) + (export \"f64.floor\" (func 23)) + (export \"f64.trunc\" (func 24)) + (export \"f64.nearest\" (func 25)) + (export \"f64.min\" (func 26)) + (export \"f64.max\" (func 27))) + "; + let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); + instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated") +} +fn start_module_1(result_object: &ResultObject, vm_context: &VmCtx) { + result_object.instance.start(&vm_context); +} + +// Line 50 +fn c1_l50_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c1_l50_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.1234568 as f32, 0.00000000012345 as f32, &vm_context); + assert_eq!(result, 1.1234568 as f32); +} + +// Line 51 +fn c2_l51_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c2_l51_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.123456789 as f64, 0.00000000012345 as f64, &vm_context); + assert_eq!(result, 1.12345678912345 as f64); +} + +// Line 55 +fn c3_l55_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c3_l55_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 0.000000059604645 as f32, &vm_context); + assert_eq!(result, 1.0 as f32); +} + +// Line 56 +fn c4_l56_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c4_l56_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 0.00000005960465 as f32, &vm_context); + assert_eq!(result, 1.0000001 as f32); +} + +// Line 57 +fn c5_l57_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c5_l57_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 0.00000000000000011102230246251565 as f64, &vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 58 +fn c6_l58_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c6_l58_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 0.00000000000000011102230246251568 as f64, &vm_context); + assert_eq!(result, 1.0000000000000002 as f64); +} + +// Line 61 +fn c7_l61_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c7_l61_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000001 as f32, 0.000000000000000000000000000000000000011754942 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000011754944 as f32); +} + +// Line 62 +fn c8_l62_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c8_l62_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64); +} + +// Line 67 +fn c9_l67_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c9_l67_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2147483600.0 as f32, 1024.25 as f32, &vm_context); + assert_eq!(result, 2147484700.0 as f32); +} + +// Line 68 +fn c10_l68_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c10_l68_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9223372036854776000.0 as f64, 1024.25 as f64, &vm_context); + assert_eq!(result, 9223372036854778000.0 as f64); +} + +// Line 72 +fn c11_l72_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c11_l72_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645561009778199 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000292 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036455610097781983 as f64); +} + +// Line 75 +fn c12_l75_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c12_l75_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9007199254740992.0 as f64, 1.00001 as f64, &vm_context); + assert_eq!(result, 9007199254740994.0 as f64); +} + +// Line 78 +fn c13_l78_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c13_l78_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9007199254740994.0 as f64, 0.9999847412109375 as f64, &vm_context); + assert_eq!(result, 9007199254740994.0 as f64); +} + +// Line 81 +fn c14_l81_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c14_l81_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8388608.0 as f32, 0.5 as f32, &vm_context); + assert_eq!(result, 8388608.0 as f32); +} + +// Line 82 +fn c15_l82_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c15_l82_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8388609.0 as f32, 0.5 as f32, &vm_context); + assert_eq!(result, 8388610.0 as f32); +} + +// Line 83 +fn c16_l83_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c16_l83_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4503599627370496.0 as f64, 0.5 as f64, &vm_context); + assert_eq!(result, 4503599627370496.0 as f64); +} + +// Line 84 +fn c17_l84_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c17_l84_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4503599627370497.0 as f64, 0.5 as f64, &vm_context); + assert_eq!(result, 4503599627370498.0 as f64); +} + +// Line 87 +fn c18_l87_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c18_l87_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-6207600000000000000000000000000.0 as f32, 0.000000000000000000000000000002309799 as f32, &vm_context); + assert_eq!(result, -6207600000000000000000000000000.0 as f32); +} + +// Line 88 +fn c19_l88_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c19_l88_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(209865800000000000000.0 as f32, -5270152500000000.0 as f32, &vm_context); + assert_eq!(result, 209860530000000000000.0 as f32); +} + +// Line 89 +fn c20_l89_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c20_l89_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000001963492 as f32, 0.000000000000000000000000000000000000046220067 as f32, &vm_context); + assert_eq!(result, 0.0000000000000000000000001963492 as f32); +} + +// Line 90 +fn c21_l90_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c21_l90_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(640905000000.0 as f32, -64449550000000000.0 as f32, &vm_context); + assert_eq!(result, -64448910000000000.0 as f32); +} + +// Line 91 +fn c22_l91_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c22_l91_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000601966 as f32, 120372790000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 120372790000000000000000000000000.0 as f32); +} + +// Line 92 +fn c23_l92_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c23_l92_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009218993827002741 as f64, -1283078243878048500000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -1283078243878048500000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 93 +fn c24_l93_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c24_l93_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-96503407870148960000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000004670208988478548 as f64, &vm_context); + assert_eq!(result, -96503407870148960000000.0 as f64); +} + +// Line 94 +fn c25_l94_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c25_l94_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000028559147675434106 as f64, -0.00026124280570653086 as f64, &vm_context); + assert_eq!(result, -0.00026124280570653086 as f64); +} + +// Line 95 +fn c26_l95_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c26_l95_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 79335564741512700000.0 as f64, &vm_context); + assert_eq!(result, 417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 96 +fn c27_l96_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c27_l96_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8265442868747023000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 99 +fn c28_l99_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c28_l99_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(5238404000000000000000.0 as f32, -1570182.5 as f32, &vm_context); + assert_eq!(result, 5238404000000000000000.0 as f32); +} + +// Line 100 +fn c29_l100_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c29_l100_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000004258938 as f32, -0.0000000000000000000000057092353 as f32, &vm_context); + assert_eq!(result, 0.00000000000004258938 as f32); +} + +// Line 101 +fn c30_l101_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c30_l101_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000027251026 as f32, 83711560000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 83711560000000000000000000000000000000.0 as f32); +} + +// Line 102 +fn c31_l102_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c31_l102_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000884536 as f32, -0.000000000000000000000000000000015165626 as f32, &vm_context); + assert_eq!(result, -0.0000000000000884536 as f32); +} + +// Line 103 +fn c32_l103_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c32_l103_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0010521035 as f32, -0.000000000000000000000000000000007582135 as f32, &vm_context); + assert_eq!(result, 0.0010521035 as f32); +} + +// Line 104 +fn c33_l104_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c33_l104_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1511135228188924600000000000000000000000000000000000000.0 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002760218100603169 as f64, &vm_context); + assert_eq!(result, 1511135228188924600000000000000000000000000000000000000.0 as f64); +} + +// Line 105 +fn c34_l105_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c34_l105_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(62386719760360280000000000000000000000000000000.0 as f64, -0.0000000000000000008592185488839212 as f64, &vm_context); + assert_eq!(result, 62386719760360280000000000000000000000000000000.0 as f64); +} + +// Line 106 +fn c35_l106_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c35_l106_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029225342022551453 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354 as f64); +} + +// Line 107 +fn c36_l107_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c36_l107_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-215220546714824520000000000000000000000000000.0 as f64, -1112220412047137200000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -216332767126871650000000000000000000000000000.0 as f64); +} + +// Line 108 +fn c37_l108_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c37_l108_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-13.6911535055856 as f64, 2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 111 +fn c38_l111_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c38_l111_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000006456021 as f32, 0.00000000000020219949 as f32, &vm_context); + assert_eq!(result, 0.00000000000020219949 as f32); +} + +// Line 112 +fn c39_l112_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c39_l112_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000026823169 as f32, 0.000000011196016 as f32, &vm_context); + assert_eq!(result, -0.000026811973 as f32); +} + +// Line 113 +fn c40_l113_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c40_l113_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-128526170000.0 as f32, 0.0000000000000000000000000000000027356305 as f32, &vm_context); + assert_eq!(result, -128526170000.0 as f32); +} + +// Line 114 +fn c41_l114_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c41_l114_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000004158973 as f32, -1573528700.0 as f32, &vm_context); + assert_eq!(result, -1573528700.0 as f32); +} + +// Line 115 +fn c42_l115_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c42_l115_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000009338769 as f32, 78647514000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 78647514000000000000000000000.0 as f32); +} + +// Line 116 +fn c43_l116_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c43_l116_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021986596650683218 as f64, -235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 117 +fn c44_l117_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c44_l117_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-314175619593595700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -30114098514611660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -314175649707694230000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 118 +fn c45_l118_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c45_l118_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013722858367681836 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977 as f64); +} + +// Line 119 +fn c46_l119_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c46_l119_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016862581574752944 as f64, &vm_context); + assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075 as f64); +} + +// Line 120 +fn c47_l120_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c47_l120_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 8374007930974482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 123 +fn c48_l123_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c48_l123_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-210896605327889950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 581483233421196300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 581483022524591100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 124 +fn c49_l124_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c49_l124_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(102315792666821480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 450204300797494900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 102315792667271680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 125 +fn c50_l125_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c50_l125_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-130529978570956560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 154899434220186570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 154899434220186450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 126 +fn c51_l126_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c51_l126_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(47629997434721684000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 127 +fn c52_l127_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c52_l127_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003958952516558414 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023092460710062946 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000230924607140219 as f64); +} + +// Line 130 +fn c53_l130_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c53_l130_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-43780558475415996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 131 +fn c54_l131_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c54_l131_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(21174311168546080000000000000000000000000000000000000000000.0 as f64, -26385928474612128000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -26385928474612128000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 132 +fn c55_l132_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c55_l132_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007858068235728165 as f64, &vm_context); + assert_eq!(result, -9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 133 +fn c56_l133_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c56_l133_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005079144928553737 as f64, -354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 134 +fn c57_l134_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c57_l134_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000004165382103988111 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010865942283516648 as f64, &vm_context); + assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000004165382103988111 as f64); +} + +// Line 137 +fn c58_l137_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c58_l137_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(97215650000000000000000000000000000.0 as f32, 305590870000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 305688080000000000000000000000000000000.0 as f32); +} + +// Line 138 +fn c59_l138_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c59_l138_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(270465630000000000000000000000000000000.0 as f32, -230236850000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 270465400000000000000000000000000000000.0 as f32); +} + +// Line 139 +fn c60_l139_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c60_l139_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(357209300000000000000000000000000000.0 as f32, -236494050000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, -236136840000000000000000000000000000000.0 as f32); +} + +// Line 140 +fn c61_l140_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c61_l140_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1484234100000000000000000000000000000.0 as f32, -328991400000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, -330475620000000000000000000000000000000.0 as f32); +} + +// Line 141 +fn c62_l141_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c62_l141_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-219885600000000000000000000000000000000.0 as f32, -81560930000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, -301446520000000000000000000000000000000.0 as f32); +} + +// Line 142 +fn c63_l142_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c63_l142_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(90390204939547630000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 22943337422040356000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 90390204939570580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 143 +fn c64_l143_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c64_l143_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(165916059736246050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 12577349331444160000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 165916059748823400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 144 +fn c65_l144_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c65_l144_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-136351292561394300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 60507030603873580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -136290785530790440000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 145 +fn c66_l145_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c66_l145_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-34377613258227424000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 169947152758793490000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 169947118381180220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 146 +fn c67_l146_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c67_l146_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(92273427008645570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -39269416451018680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 92273426969376150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 149 +fn c68_l149_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c68_l149_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000008313455 as f32, 0.000000000000000000000000000000000000000000873 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000008314328 as f32); +} + +// Line 150 +fn c69_l150_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c69_l150_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000052 as f32, -0.000000000000000000000000000000000000000000003 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000049 as f32); +} + +// Line 151 +fn c70_l151_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c70_l151_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000011 as f32, 0.000000000000000000000000000000000000005186284 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000005186273 as f32); +} + +// Line 152 +fn c71_l152_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c71_l152_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000028 as f32, 0.00000000000000000000000000000000000023675283 as f32, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000002367528 as f32); +} + +// Line 153 +fn c72_l153_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c72_l153_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000635 as f32, -0.00000000000000000000000000000000000000003327 as f32, &vm_context); + assert_eq!(result, -0.000000000000000000000000000000000000000032635 as f32); +} + +// Line 154 +fn c73_l154_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c73_l154_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028461489375936755 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005130160608603642 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002284011671009967 as f64); +} + +// Line 155 +fn c74_l155_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c74_l155_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047404811354775 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008895417776504167 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004154936641026667 as f64); +} + +// Line 156 +fn c75_l156_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c75_l156_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009330082001250494 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029863980609419717 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003919406261067021 as f64); +} + +// Line 157 +fn c76_l157_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c76_l157_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014418693884494008 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016324914377759187 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001906220493265178 as f64); +} + +// Line 158 +fn c77_l158_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c77_l158_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043203619362281506 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002521511966399844 as f64, &vm_context); + assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017988499698283067 as f64); +} + +// Line 162 +fn c78_l162_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c78_l162_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(340282330000000000000000000000000000000.0 as f32, 20282410000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 340282350000000000000000000000000000000.0 as f32); +} + +// Line 163 +fn c79_l163_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c79_l163_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 19958403095347200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 166 +fn c80_l166_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c80_l166_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2.0 as f32, 2.0 as f32, &vm_context); + assert_eq!(result, 4.0 as f32); +} + +// Line 167 +fn c81_l167_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c81_l167_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2.0 as f64, 2.0 as f64, &vm_context); + assert_eq!(result, 4.0 as f64); +} + +// Line 170 +fn c82_l170_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c82_l170_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(340282350000000000000000000000000000000.0 as f32, 10141204000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 340282350000000000000000000000000000000.0 as f32); +} + +// Line 171 +fn c83_l171_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c83_l171_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(340282350000000000000000000000000000000.0 as f32, 10141205000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, std::f32::INFINITY); +} + +// Line 172 +fn c84_l172_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c84_l172_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 173 +fn c85_l173_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c85_l173_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.add") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, std::f64::INFINITY); +} + +// Line 177 +fn c86_l177_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c86_l177_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(65536.0 as f32, 0.000000000007275958 as f32, &vm_context); + assert_eq!(result, 65536.0 as f32); +} + +// Line 178 +fn c87_l178_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c87_l178_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(65536.0 as f64, 0.000000000007275957614183426 as f64, &vm_context); + assert_eq!(result, 65535.99999999999 as f64); +} + +// Line 182 +fn c88_l182_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c88_l182_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 0.000000029802322 as f32, &vm_context); + assert_eq!(result, 1.0 as f32); +} + +// Line 183 +fn c89_l183_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c89_l183_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 0.000000029802326 as f32, &vm_context); + assert_eq!(result, 0.99999994 as f32); +} + +// Line 184 +fn c90_l184_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c90_l184_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 0.00000000000000005551115123125783 as f64, &vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 185 +fn c91_l185_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c91_l185_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 0.00000000000000005551115123125784 as f64, &vm_context); + assert_eq!(result, 0.9999999999999999 as f64); +} + +// Line 188 +fn c92_l188_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c92_l188_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000002379208 as f32, -722129800000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 722129800000000000000000000000000000.0 as f32); +} + +// Line 189 +fn c93_l189_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c93_l189_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-842284000000000000000000000000000000.0 as f32, -11118414000000.0 as f32, &vm_context); + assert_eq!(result, -842284000000000000000000000000000000.0 as f32); +} + +// Line 190 +fn c94_l190_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c94_l190_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.4549444 as f32, -0.00000000000000000000000033792615 as f32, &vm_context); + assert_eq!(result, 1.4549444 as f32); +} + +// Line 191 +fn c95_l191_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c95_l191_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000094808914 as f32, 0.000000000000000000000018589502 as f32, &vm_context); + assert_eq!(result, -0.000000000000000000000018589502 as f32); +} + +// Line 192 +fn c96_l192_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c96_l192_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000006181167 as f32, -0.0000000000000000000000000000000093959864 as f32, &vm_context); + assert_eq!(result, 0.000006181167 as f32); +} + +// Line 193 +fn c97_l193_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c97_l193_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002524845082116609 as f64, &vm_context); + assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413 as f64); +} + +// Line 194 +fn c98_l194_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c98_l194_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.0000000000000000000000000000000000000000000000038165079778426864 as f64, &vm_context); + assert_eq!(result, -20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 195 +fn c99_l195_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c99_l195_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020889465194336087 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332 as f64); +} + +// Line 196 +fn c100_l196_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c100_l196_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000303879528930943 as f64, -23204941114021897000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 23204941114021897000000000000000000000000000000.0 as f64); +} + +// Line 197 +fn c101_l197_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c101_l197_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000000000000000000000014953904039036317 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010592252695645683 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000014953904039036317 as f64); +} + +// Line 200 +fn c102_l200_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c102_l200_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-448601660000000000000000000000000.0 as f32, -8984148000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 8535546400000000000000000000000000.0 as f32); +} + +// Line 201 +fn c103_l201_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c103_l201_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-899427400000000000000000000000000.0 as f32, 91.579384 as f32, &vm_context); + assert_eq!(result, -899427400000000000000000000000000.0 as f32); +} + +// Line 202 +fn c104_l202_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c104_l202_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000011975 as f32, 0.000000063140405 as f32, &vm_context); + assert_eq!(result, -0.000000063140405 as f32); +} + +// Line 203 +fn c105_l203_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c105_l203_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000011800487 as f32, -0.00031558736 as f32, &vm_context); + assert_eq!(result, 0.00031558736 as f32); +} + +// Line 204 +fn c106_l204_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c106_l204_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-736483800000000000000000000000.0 as f32, 0.0000000000000000030824513 as f32, &vm_context); + assert_eq!(result, -736483800000000000000000000000.0 as f32); +} + +// Line 205 +fn c107_l205_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c107_l205_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-9410469964196796000000000000000000000000000000000000000000000.0 as f64, -17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 206 +fn c108_l206_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c108_l206_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002339448785991429 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173 as f64); +} + +// Line 207 +fn c109_l207_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c109_l207_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000009719219783531962 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001572015082308034 as f64, &vm_context); + assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000009719219783531962 as f64); +} + +// Line 208 +fn c110_l208_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c110_l208_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034908896031751274 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208 as f64); +} + +// Line 209 +fn c111_l209_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c111_l209_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-7538298763725556000000000000000000.0 as f64, 4447012580193329000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -4447012580193329000000000000000000000000000000000000.0 as f64); +} + +// Line 212 +fn c112_l212_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c112_l212_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(75846976000000000000000000000.0 as f32, 0.000046391753 as f32, &vm_context); + assert_eq!(result, 75846976000000000000000000000.0 as f32); +} + +// Line 213 +fn c113_l213_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c113_l213_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-567139.9 as f32, -0.000000000030334842 as f32, &vm_context); + assert_eq!(result, -567139.9 as f32); +} + +// Line 214 +fn c114_l214_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c114_l214_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000017412261 as f32, -0.000000000000000017877793 as f32, &vm_context); + assert_eq!(result, -0.000000000017412244 as f32); +} + +// Line 215 +fn c115_l215_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c115_l215_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000065645545 as f32, 0.00014473806 as f32, &vm_context); + assert_eq!(result, -0.00021038362 as f32); +} + +// Line 216 +fn c116_l216_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c116_l216_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000016016115 as f32, -0.000000000000000000000000000000085380075 as f32, &vm_context); + assert_eq!(result, -0.00000000016016115 as f32); +} + +// Line 217 +fn c117_l217_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c117_l217_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000009358725267183177 as f64, -31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 218 +fn c118_l218_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c118_l218_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4390767596767215000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 219 +fn c119_l219_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c119_l219_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036288281010831153 as f64, 3383199683245004400000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -3383199683245004400000000000000000000000000000000000000.0 as f64); +} + +// Line 220 +fn c120_l220_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c120_l220_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645097751812619 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423490969686624 as f64, &vm_context); + assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423491006137603 as f64); +} + +// Line 221 +fn c121_l221_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c121_l221_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008021529638989887 as f64, -0.00006774972769072139 as f64, &vm_context); + assert_eq!(result, 0.00006774972769072139 as f64); +} + +// Line 224 +fn c122_l224_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c122_l224_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000005816988065793039 as f64, 0.000000000000000000000000000000000025021499241540866 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000005816988065768018 as f64); +} + +// Line 225 +fn c123_l225_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c123_l225_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683304809554 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016945582607476316 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683135353726 as f64); +} + +// Line 226 +fn c124_l226_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c124_l226_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000006908052676315257 as f64, 0.0000000000000000000000000000000000000000000000000000000000012001773734799856 as f64, &vm_context); + assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000012001773734799856 as f64); +} + +// Line 227 +fn c125_l227_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c125_l227_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000022044291547443813 as f64, -0.0000000000000000000027947429925618632 as f64, &vm_context); + assert_eq!(result, -0.000000000002204429151949638 as f64); +} + +// Line 228 +fn c126_l228_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c126_l228_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000004016393569117761 as f64, 0.17053881989395447 as f64, &vm_context); + assert_eq!(result, -0.17053877973001877 as f64); +} + +// Line 231 +fn c127_l231_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c127_l231_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010015106898667285 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004785375958943186 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047853759589431757 as f64); +} + +// Line 232 +fn c128_l232_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c128_l232_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-15618959953.641388 as f64, 598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 233 +fn c129_l233_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c129_l233_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(38832071540376680000000000000000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042192279274320304 as f64, &vm_context); + assert_eq!(result, 38832071540376680000000000000000000.0 as f64); +} + +// Line 234 +fn c130_l234_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c130_l234_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017466607734737216 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897 as f64); +} + +// Line 235 +fn c131_l235_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c131_l235_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000949378346261834 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014584885434950294 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000949378346261834 as f64); +} + +// Line 239 +fn c132_l239_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c132_l239_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(23.140692 as f32, 3.1415927 as f32, &vm_context); + assert_eq!(result, 19.9991 as f32); +} + +// Line 240 +fn c133_l240_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c133_l240_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(23.14069263277927 as f64, 3.141592653589793 as f64, &vm_context); + assert_eq!(result, 19.999099979189477 as f64); +} + +// Line 243 +fn c134_l243_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c134_l243_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2999999.0 as f32, 2999998.0 as f32, &vm_context); + assert_eq!(result, 1.0 as f32); +} + +// Line 244 +fn c135_l244_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c135_l244_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1999999.0 as f32, 1999995.0 as f32, &vm_context); + assert_eq!(result, 4.0 as f32); +} + +// Line 245 +fn c136_l245_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c136_l245_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1999999.0 as f32, 1999993.0 as f32, &vm_context); + assert_eq!(result, 6.0 as f32); +} + +// Line 246 +fn c137_l246_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c137_l246_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(400002.0 as f32, 400001.0 as f32, &vm_context); + assert_eq!(result, 1.0 as f32); +} + +// Line 247 +fn c138_l247_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c138_l247_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(400002.0 as f32, 400000.0 as f32, &vm_context); + assert_eq!(result, 2.0 as f32); +} + +// Line 248 +fn c139_l248_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c139_l248_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2999999999999999.0 as f64, 2999999999999998.0 as f64, &vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 249 +fn c140_l249_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c140_l249_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1999999999999999.0 as f64, 1999999999999995.0 as f64, &vm_context); + assert_eq!(result, 4.0 as f64); +} + +// Line 250 +fn c141_l250_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c141_l250_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1999999999999999.0 as f64, 1999999999999993.0 as f64, &vm_context); + assert_eq!(result, 6.0 as f64); +} + +// Line 251 +fn c142_l251_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c142_l251_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(400000000000002.0 as f64, 400000000000001.0 as f64, &vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 252 +fn c143_l252_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c143_l252_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(400000000000002.0 as f64, 400000000000000.0 as f64, &vm_context); + assert_eq!(result, 2.0 as f64); +} + +// Line 255 +fn c144_l255_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c144_l255_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000011754944 as f32, 0.000000000000000000000000000000000000011754942 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000001 as f32); +} + +// Line 256 +fn c145_l256_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c145_l256_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64); +} + +// Line 259 +fn c146_l259_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c146_l259_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000001 as f32, 0.99999994 as f32, &vm_context); + assert_eq!(result, 0.00000017881393 as f32); +} + +// Line 260 +fn c147_l260_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c147_l260_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000001 as f32, 1.0 as f32, &vm_context); + assert_eq!(result, 0.00000011920929 as f32); +} + +// Line 261 +fn c148_l261_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c148_l261_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 0.99999994 as f32, &vm_context); + assert_eq!(result, 0.000000059604645 as f32); +} + +// Line 262 +fn c149_l262_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c149_l262_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000002 as f64, 0.9999999999999999 as f64, &vm_context); + assert_eq!(result, 0.00000000000000033306690738754696 as f64); +} + +// Line 263 +fn c150_l263_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c150_l263_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000002 as f64, 1.0 as f64, &vm_context); + assert_eq!(result, 0.0000000000000002220446049250313 as f64); +} + +// Line 264 +fn c151_l264_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c151_l264_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 0.9999999999999999 as f64, &vm_context); + assert_eq!(result, 0.00000000000000011102230246251565 as f64); +} + +// Line 268 +fn c152_l268_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c152_l268_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(340282350000000000000000000000000000000.0 as f32, 10141204000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 340282350000000000000000000000000000000.0 as f32); +} + +// Line 269 +fn c153_l269_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c153_l269_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(340282350000000000000000000000000000000.0 as f32, 10141205000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 340282330000000000000000000000000000000.0 as f32); +} + +// Line 270 +fn c154_l270_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c154_l270_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 271 +fn c155_l271_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c155_l271_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sub") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 274 +fn c156_l274_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c156_l274_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1000000000000000.0 as f32, 1000000000000000.0 as f32, &vm_context); + assert_eq!(result, 999999940000000000000000000000.0 as f32); +} + +// Line 275 +fn c157_l275_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c157_l275_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(100000000000000000000.0 as f32, 100000000000000000000.0 as f32, &vm_context); + assert_eq!(result, std::f32::INFINITY); +} + +// Line 276 +fn c158_l276_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c158_l276_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(10000000000000000000000000.0 as f32, 10000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, std::f32::INFINITY); +} + +// Line 277 +fn c159_l277_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c159_l277_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1000000000000000.0 as f64, 1000000000000000.0 as f64, &vm_context); + assert_eq!(result, 1000000000000000000000000000000.0 as f64); +} + +// Line 278 +fn c160_l278_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c160_l278_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(100000000000000000000.0 as f64, 100000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 10000000000000000000000000000000000000000.0 as f64); +} + +// Line 279 +fn c161_l279_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c161_l279_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(10000000000000000000000000.0 as f64, 10000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 100000000000000030000000000000000000000000000000000.0 as f64); +} + +// Line 284 +fn c162_l284_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c162_l284_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1848874900.0 as f32, 19954563000.0 as f32, &vm_context); + assert_eq!(result, 36893493000000000000.0 as f32); +} + +// Line 285 +fn c163_l285_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c163_l285_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1848874847.0 as f64, 19954562207.0 as f64, &vm_context); + assert_eq!(result, 36893488147419110000.0 as f64); +} + +// Line 289 +fn c164_l289_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c164_l289_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(77.1 as f32, 850.0 as f32, &vm_context); + assert_eq!(result, 65535.0 as f32); +} + +// Line 290 +fn c165_l290_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c165_l290_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(77.1 as f64, 850.0 as f64, &vm_context); + assert_eq!(result, 65534.99999999999 as f64); +} + +// Line 293 +fn c166_l293_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c166_l293_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-2493839400000000000.0 as f32, 0.000000000021176054 as f32, &vm_context); + assert_eq!(result, -52809680.0 as f32); +} + +// Line 294 +fn c167_l294_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c167_l294_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-6777248400000000000000000000000.0 as f32, -0.00000000000000000000000000000034758242 as f32, &vm_context); + assert_eq!(result, 2.3556523 as f32); +} + +// Line 295 +fn c168_l295_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c168_l295_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-8384397600000000000000000000.0 as f32, -0.000000000000000000000000000011948991 as f32, &vm_context); + assert_eq!(result, 0.10018509 as f32); +} + +// Line 296 +fn c169_l296_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c169_l296_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-656765400000000000000000.0 as f32, -0.000000000000000000000046889766 as f32, &vm_context); + assert_eq!(result, 30.795576 as f32); +} + +// Line 297 +fn c170_l297_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c170_l297_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(13328204000000000.0 as f32, 45.567223 as f32, &vm_context); + assert_eq!(result, 607329200000000000.0 as f32); +} + +// Line 298 +fn c171_l298_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c171_l298_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-99426226093342430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 583177241514245140000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, std::f64::NEG_INFINITY); +} + +// Line 299 +fn c172_l299_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c172_l299_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002748155824301909 as f64, -0.000000000000000000000000000000000000000000000000000000000000000002093035437779455 as f64, &vm_context); + assert_eq!(result, 0.0 as f64); +} + +// Line 300 +fn c173_l300_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c173_l300_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(464888257371302500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -159272886487254360000000000000000.0 as f64, &vm_context); + assert_eq!(result, -74044094645556960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 301 +fn c174_l301_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c174_l301_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008261927764172427 as f64, 36684744190529535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -3030867065492991300000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 302 +fn c175_l302_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c175_l302_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(253838958331769250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007842892881810105 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000019908317594263248 as f64); +} + +// Line 305 +fn c176_l305_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c176_l305_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000020153333 as f32, -5031353000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 10.139854 as f32); +} + +// Line 306 +fn c177_l306_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c177_l306_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(12286325000000000000000.0 as f32, 749601.8 as f32, &vm_context); + assert_eq!(result, 9209852000000000000000000000.0 as f32); +} + +// Line 307 +fn c178_l307_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c178_l307_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000002763514 as f32, -35524714000000000000000.0 as f32, &vm_context); + assert_eq!(result, 9817304000000.0 as f32); +} + +// Line 308 +fn c179_l308_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c179_l308_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(218931220000000000000.0 as f32, -40298.785 as f32, &vm_context); + assert_eq!(result, -8822662000000000000000000.0 as f32); +} + +// Line 309 +fn c180_l309_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c180_l309_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1691996300.0 as f32, -122103350000000000000.0 as f32, &vm_context); + assert_eq!(result, -206598410000000000000000000000.0 as f32); +} + +// Line 310 +fn c181_l310_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c181_l310_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007576316076452304 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004601355879514986 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003486132652344772 as f64); +} + +// Line 311 +fn c182_l311_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c182_l311_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012228616081443885 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008055526185180067 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009850793705258527 as f64); +} + +// Line 312 +fn c183_l312_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c183_l312_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-2068651246039250800000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -366801071583254800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, std::f64::INFINITY); +} + +// Line 313 +fn c184_l313_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c184_l313_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1543238835610281000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007370621385787007 as f64, &vm_context); + assert_eq!(result, 1137462916512617700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 314 +fn c185_l314_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c185_l314_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2235876566242058700000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -760669005920257000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -1700762005003744000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 317 +fn c186_l317_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c186_l317_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-110087030000000.0 as f32, -54038020000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, std::f32::INFINITY); +} + +// Line 318 +fn c187_l318_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c187_l318_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.19366351 as f32, 0.0000000000000000000000000000029748954 as f32, &vm_context); + assert_eq!(result, -0.0000000000000000000000000000005761287 as f32); +} + +// Line 319 +fn c188_l319_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c188_l319_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000034300713 as f32, 77991523000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, -267516490000000000000000000.0 as f32); +} + +// Line 320 +fn c189_l320_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c189_l320_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-99003850000000000.0 as f32, 0.000000000000000000000000000020933774 as f32, &vm_context); + assert_eq!(result, -0.0000000000020725242 as f32); +} + +// Line 321 +fn c190_l321_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c190_l321_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-129919.07 as f32, 0.0000000000000000000000000000000000018480999 as f32, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000024010342 as f32); +} + +// Line 322 +fn c191_l322_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c191_l322_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006625572200844895 as f64, -37374020681740010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000024762427246273877 as f64); +} + +// Line 323 +fn c192_l323_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c192_l323_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(821076848561758000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012976552328552289 as f64, &vm_context); + assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000010654746691124455 as f64); +} + +// Line 324 +fn c193_l324_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c193_l324_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-10223449294906041000000000000000000000000000000000000.0 as f64, 1970855583334680500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -20148942123804574000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 325 +fn c194_l325_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c194_l325_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2918243080119086000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -63633170941689700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, std::f64::NEG_INFINITY); +} + +// Line 326 +fn c195_l326_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c195_l326_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(3407037798802672000000000.0 as f64, 1225791423971563000000.0 as f64, &vm_context); + assert_eq!(result, 4176317714919266400000000000000000000000000000.0 as f64); +} + +// Line 329 +fn c196_l329_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c196_l329_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044091927284399547 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011518840702296592 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005078878866462432 as f64); +} + +// Line 330 +fn c197_l330_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c197_l330_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.002980041826472432 as f64, 63125412993218000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -188116371033135940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 331 +fn c198_l331_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c198_l331_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-308344578081300100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010081049555008529 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000031084369716557833 as f64); +} + +// Line 332 +fn c199_l332_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c199_l332_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(349387501315677300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 2131316915930809900.0 as f64, &vm_context); + assert_eq!(result, 744655491768901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 333 +fn c200_l333_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c200_l333_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012500108005100234 as f64, 1035265704160467500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -12940933115981990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 336 +fn c201_l336_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c201_l336_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008947461661755698 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020853844141312436 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018658897095462173 as f64); +} + +// Line 337 +fn c202_l337_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c202_l337_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000001161813037330394 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018737038135583668 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021768935186877886 as f64); +} + +// Line 338 +fn c203_l338_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c203_l338_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021752326768352433 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006631210068072052 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014424424827029184 as f64); +} + +// Line 339 +fn c204_l339_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c204_l339_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007149518157441743 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000022770445062365393 as f64, &vm_context); + assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001627977104264113 as f64); +} + +// Line 340 +fn c205_l340_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c205_l340_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004817739302150786 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025375023049719763 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012225024583961697 as f64); +} + +// Line 343 +fn c206_l343_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c206_l343_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(46576441629501554000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007021344893525714 as f64, &vm_context); + assert_eq!(result, 0.000000003270292605938992 as f64); +} + +// Line 344 +fn c207_l344_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c207_l344_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.012451716278313712 as f64, 0.000000000000000000000000000000000000000000001945309177849331 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000002422243795617958 as f64); +} + +// Line 345 +fn c208_l345_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c208_l345_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-3.8312314777598586 as f64, 0.0000000000009039887741742674 as f64, &vm_context); + assert_eq!(result, -0.0000000000034633902471580017 as f64); +} + +// Line 346 +fn c209_l346_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c209_l346_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009843582638849689 as f64, 0.00000000000000000000000000000000000000000000000000000000000003375405654777583 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000033226084502443684 as f64); +} + +// Line 347 +fn c210_l347_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c210_l347_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-260544537094514460000000.0 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032887528185809035 as f64, &vm_context); + assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000008568665807354412 as f64); +} + +// Line 350 +fn c211_l350_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c211_l350_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000002646978 as f32, 0.00000000000000000000002646978 as f32, &vm_context); + assert_eq!(result, 0.0 as f32); +} + +// Line 351 +fn c212_l351_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c212_l351_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000026469783 as f32, 0.000000000000000000000026469783 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000001 as f32); +} + +// Line 352 +fn c213_l352_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c213_l352_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285 as f64, &vm_context); + assert_eq!(result, 0.0 as f64); +} + +// Line 353 +fn c214_l353_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c214_l353_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64); +} + +// Line 356 +fn c215_l356_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c215_l356_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(18446743000000000000.0 as f32, 18446743000000000000.0 as f32, &vm_context); + assert_eq!(result, 340282330000000000000000000000000000000.0 as f32); +} + +// Line 357 +fn c216_l357_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c216_l357_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(18446744000000000000.0 as f32, 18446744000000000000.0 as f32, &vm_context); + assert_eq!(result, std::f32::INFINITY); +} + +// Line 358 +fn c217_l358_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c217_l358_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 359 +fn c218_l359_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c218_l359_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, std::f64::INFINITY); +} + +// Line 362 +fn c219_l362_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c219_l362_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000001 as f32, 1.0000001 as f32, &vm_context); + assert_eq!(result, 1.0000002 as f32); +} + +// Line 363 +fn c220_l363_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c220_l363_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.99999994 as f32, 0.99999994 as f32, &vm_context); + assert_eq!(result, 0.9999999 as f32); +} + +// Line 364 +fn c221_l364_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c221_l364_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000002 as f64, 1.0000000000000002 as f64, &vm_context); + assert_eq!(result, 1.0000000000000004 as f64); +} + +// Line 365 +fn c222_l365_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c222_l365_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.9999999999999999 as f64, 0.9999999999999999 as f64, &vm_context); + assert_eq!(result, 0.9999999999999998 as f64); +} + +// Line 368 +fn c223_l368_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c223_l368_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000001 as f32, 0.99999994 as f32, &vm_context); + assert_eq!(result, 1.0 as f32); +} + +// Line 369 +fn c224_l369_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c224_l369_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000002 as f32, 0.9999999 as f32, &vm_context); + assert_eq!(result, 1.0000001 as f32); +} + +// Line 370 +fn c225_l370_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c225_l370_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000002 as f64, 0.9999999999999999 as f64, &vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 371 +fn c226_l371_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c226_l371_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000004 as f64, 0.9999999999999998 as f64, &vm_context); + assert_eq!(result, 1.0000000000000002 as f64); +} + +// Line 375 +fn c227_l375_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c227_l375_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000011754944 as f32, 0.00000011920929 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000001 as f32); +} + +// Line 376 +fn c228_l376_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c228_l376_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64, 0.0000000000000002220446049250313 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64); +} + +// Line 379 +fn c229_l379_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c229_l379_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.mul") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-16.001465 as f32, 0.000000000000000000000000000000000000000298465 as f32, &vm_context); + assert_eq!(result, -0.000000000000000000000000000000000000004775883 as f32); +} + +// Line 382 +fn c230_l382_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c230_l382_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.1234568 as f32, 100.0 as f32, &vm_context); + assert_eq!(result, 0.011234568 as f32); +} + +// Line 383 +fn c231_l383_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c231_l383_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8391667.0 as f32, 12582905.0 as f32, &vm_context); + assert_eq!(result, 0.6669102 as f32); +} + +// Line 384 +fn c232_l384_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c232_l384_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(65536.0 as f32, 0.000000000007275958 as f32, &vm_context); + assert_eq!(result, 9007199000000000.0 as f32); +} + +// Line 385 +fn c233_l385_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c233_l385_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.8622957 as f32, 340282350000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000005472795 as f32); +} + +// Line 386 +fn c234_l386_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c234_l386_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4.0 as f32, 3.0 as f32, &vm_context); + assert_eq!(result, 1.3333334 as f32); +} + +// Line 387 +fn c235_l387_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c235_l387_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.123456789 as f64, 100.0 as f64, &vm_context); + assert_eq!(result, 0.01123456789 as f64); +} + +// Line 388 +fn c236_l388_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c236_l388_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8391667.0 as f64, 12582905.0 as f64, &vm_context); + assert_eq!(result, 0.6669101451532854 as f64); +} + +// Line 389 +fn c237_l389_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c237_l389_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(65536.0 as f64, 0.000000000007275957614183426 as f64, &vm_context); + assert_eq!(result, 9007199254740992.0 as f64); +} + +// Line 390 +fn c238_l390_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c238_l390_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.8622957468032837 as f64, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001035936395755283 as f64); +} + +// Line 391 +fn c239_l391_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c239_l391_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4.0 as f64, 3.0 as f64, &vm_context); + assert_eq!(result, 1.3333333333333333 as f64); +} + +// Line 395 +fn c240_l395_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c240_l395_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4195835.0 as f32, 3145727.0 as f32, &vm_context); + assert_eq!(result, 1.3338205 as f32); +} + +// Line 396 +fn c241_l396_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c241_l396_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4195835.0 as f64, 3145727.0 as f64, &vm_context); + assert_eq!(result, 1.333820449136241 as f64); +} + +// Line 399 +fn c242_l399_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c242_l399_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000005029633 as f32, 336324380000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 0.0 as f32); +} + +// Line 400 +fn c243_l400_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c243_l400_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000008921987 as f32, 354097530000000000000.0 as f32, &vm_context); + assert_eq!(result, 0.0 as f32); +} + +// Line 401 +fn c244_l401_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c244_l401_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-104167.47 as f32, 0.0000000000000000000000015866623 as f32, &vm_context); + assert_eq!(result, -65651950000000000000000000000.0 as f32); +} + +// Line 402 +fn c245_l402_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c245_l402_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000024938657 as f32, -0.00000000000000000000000000000000000036230088 as f32, &vm_context); + assert_eq!(result, 68834107000000.0 as f32); +} + +// Line 403 +fn c246_l403_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c246_l403_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4142204200000.0 as f32, 0.0000000000000000000000011954948 as f32, &vm_context); + assert_eq!(result, -3464845000000000000000000000000000000.0 as f32); +} + +// Line 404 +fn c247_l404_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c247_l404_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(193901163824483840000000000000000000000000000.0 as f64, 25290742357348314000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000007666883046955921 as f64); +} + +// Line 405 +fn c248_l405_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c248_l405_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006600332149752304 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003007915153468629 as f64, &vm_context); + assert_eq!(result, 219432125342399270000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 406 +fn c249_l406_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c249_l406_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-934827517366190300000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 4809309529035847000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019437873809582001 as f64); +} + +// Line 407 +fn c250_l407_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c250_l407_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-17598339088417535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 199386072580682850000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -88262629684409150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 408 +fn c251_l408_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c251_l408_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4566268877844991000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 31282495822334530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -145968816036246260000000000.0 as f64); +} + +// Line 411 +fn c252_l411_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c252_l411_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1039406400000000000000.0 as f32, -0.000000000000000000000000012965966 as f32, &vm_context); + assert_eq!(result, std::f32::INFINITY); +} + +// Line 412 +fn c253_l412_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c253_l412_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000026831563 as f32, 31241038000000.0 as f32, &vm_context); + assert_eq!(result, 0.0000000000000000000000000008588563 as f32); +} + +// Line 413 +fn c254_l413_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c254_l413_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.2734247 as f32, -692783700000000000000000000.0 as f32, &vm_context); + assert_eq!(result, -0.0000000000000000000000000018381274 as f32); +} + +// Line 414 +fn c255_l414_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c255_l414_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000068988827 as f32, 0.000000000000000000000000000000000000003762676 as f32, &vm_context); + assert_eq!(result, 183350460000000000000000.0 as f32); +} + +// Line 415 +fn c256_l415_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c256_l415_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1819916200000000000000000000.0 as f32, 205067030000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 8.874739 as f32); +} + +// Line 416 +fn c257_l416_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c257_l416_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021137715924428077 as f64, -16733261612910253000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -0.0 as f64); +} + +// Line 417 +fn c258_l417_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c258_l417_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008116644948016275 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006517571349002277 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012453480772801648 as f64); +} + +// Line 418 +fn c259_l418_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c259_l418_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009335476912259029 as f64, -39099281466396.5 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023876338802497726 as f64); +} + +// Line 419 +fn c260_l419_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c260_l419_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1686856985488590200000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013535993861076857 as f64, &vm_context); + assert_eq!(result, -12462010568276012000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 420 +fn c261_l420_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c261_l420_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-173388773324941200000000000000000000000000000000000000000000000000000000.0 as f64, -70026160475217470.0 as f64, &vm_context); + assert_eq!(result, 2476057121342590000000000000000000000000000000000000000.0 as f64); +} + +// Line 423 +fn c262_l423_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c262_l423_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(93506190.0 as f32, 0.0000000000000000000000000000000000028760885 as f32, &vm_context); + assert_eq!(result, std::f32::INFINITY); +} + +// Line 424 +fn c263_l424_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c263_l424_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-200575400000000000000000.0 as f32, 246697220.0 as f32, &vm_context); + assert_eq!(result, -813042800000000.0 as f32); +} + +// Line 425 +fn c264_l425_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c264_l425_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(384712200000.0 as f32, -107037850000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, -0.00000000000000000359417 as f32); +} + +// Line 426 +fn c265_l426_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c265_l426_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4156665000000000000000000000000000.0 as f32, -901.4192 as f32, &vm_context); + assert_eq!(result, 4611245300000000000000000000000.0 as f32); +} + +// Line 427 +fn c266_l427_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c266_l427_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-6702387000000000000000000000.0 as f32, -14000.255 as f32, &vm_context); + assert_eq!(result, 478733200000000000000000.0 as f32); +} + +// Line 428 +fn c267_l428_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c267_l428_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010085269598907525 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018780374032850215 as f64, &vm_context); + assert_eq!(result, -53701111496.85621 as f64); +} + +// Line 429 +fn c268_l429_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c268_l429_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-32571664562951100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005885738519211168 as f64, &vm_context); + assert_eq!(result, std::f64::INFINITY); +} + +// Line 430 +fn c269_l430_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c269_l430_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031640946861233317 as f64, 0.000000000000000000045854510556516254 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006900291046010721 as f64); +} + +// Line 431 +fn c270_l431_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c270_l431_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-526842242946656600000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014816907071451201 as f64, &vm_context); + assert_eq!(result, 355568298030134360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 432 +fn c271_l432_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c271_l432_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4039956270017490000000000000000000000000000000000000000.0 as f64, -47097881971884274000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -0.0000000000857778757955442 as f64); +} + +// Line 435 +fn c272_l435_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c272_l435_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-203959560468347600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -74740887394612260000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 2728888665604071000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 436 +fn c273_l436_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c273_l436_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-304261712294687660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -2655679232658824300000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 114570204320220420000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 437 +fn c274_l437_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c274_l437_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(49235240512480730000000000000000000000000000000000000000.0 as f64, -366340828310036700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013439736089369927 as f64); +} + +// Line 438 +fn c275_l438_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c275_l438_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(289260843556341600000000000000000000000000000000000000000000000000.0 as f64, 517194875837335500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000005592879146144478 as f64); +} + +// Line 439 +fn c276_l439_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c276_l439_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-421542582344268600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 1428505854670649100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -295093352936560340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 442 +fn c277_l442_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c277_l442_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.8622957433108482 as f64, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010359363938125513 as f64); +} + +// Line 443 +fn c278_l443_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c278_l443_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008566632480779937 as f64, 5381.2699796556235 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001591935084685746 as f64); +} + +// Line 444 +fn c279_l444_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c279_l444_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000000000000000000000008196220919495565 as f64, -10406557086484777000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007876015911295176 as f64); +} + +// Line 445 +fn c280_l445_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c280_l445_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007052801866447111 as f64, -13767429405781133000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005122816800851397 as f64); +} + +// Line 446 +fn c281_l446_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c281_l446_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022655621734165475 as f64, 133219932963494700000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017006180103974106 as f64); +} + +// Line 447 +fn c282_l447_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c282_l447_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004196304106554003 as f64, -9789327.297653636 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042866113053139 as f64); +} + +// Line 450 +fn c283_l450_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c283_l450_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1038860800000000000000000000.0 as f32, 6211079500000.0 as f32, &vm_context); + assert_eq!(result, 167259300000000.0 as f32); +} + +// Line 451 +fn c284_l451_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c284_l451_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1869033000000000000000000000.0 as f32, -112355730000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, -0.00001663496 as f32); +} + +// Line 452 +fn c285_l452_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c285_l452_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(3290747200000000000000000.0 as f32, 0.9064788 as f32, &vm_context); + assert_eq!(result, 3630252700000000000000000.0 as f32); +} + +// Line 453 +fn c286_l453_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c286_l453_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-908946.56 as f32, -17034289000.0 as f32, &vm_context); + assert_eq!(result, 0.000053359818 as f32); +} + +// Line 454 +fn c287_l454_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c287_l454_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000024092477 as f32, -89840810000000000.0 as f32, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000026816852 as f32); +} + +// Line 455 +fn c288_l455_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c288_l455_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(3910973045785834000.0 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008392730733897136 as f64, &vm_context); + assert_eq!(result, -46599529638070336000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 456 +fn c289_l456_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c289_l456_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000008379351966732404 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021077277802048832 as f64, &vm_context); + assert_eq!(result, -3975538039318286000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 457 +fn c290_l457_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c290_l457_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4561142017854715000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 1500578067736849100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 3039589952.6465592 as f64); +} + +// Line 458 +fn c291_l458_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c291_l458_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-6236072401827852000000000000000000000000000000000000000.0 as f64, 83170632504609900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007497925907299316 as f64); +} + +// Line 459 +fn c292_l459_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c292_l459_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009757271330468098 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035613812243480865 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000002739743575824061 as f64); +} + +// Line 462 +fn c293_l462_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c293_l462_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000001046256872449641 as f64, 1.8150892711657447 as f64, &vm_context); + assert_eq!(result, 0.000000000000000005764217160391678 as f64); +} + +// Line 463 +fn c294_l463_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c294_l463_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000022038268106596436 as f64, -0.0000000000002859803943943555 as f64, &vm_context); + assert_eq!(result, -0.0000000000000000007706216418530616 as f64); +} + +// Line 464 +fn c295_l464_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c295_l464_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000007596539988437179 as f64, 0.00000000000000000000000000000000021055358831337124 as f64, &vm_context); + assert_eq!(result, 3607889112357986600000.0 as f64); +} + +// Line 465 +fn c296_l465_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c296_l465_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1120696114500866900000000000.0 as f64, 159713233802866500000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.007016927074960728 as f64); +} + +// Line 466 +fn c297_l466_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c297_l466_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0006342142502301953 as f64, -6391950865520085.0 as f64, &vm_context); + assert_eq!(result, -0.00000000000000000009922076429769178 as f64); +} + +// Line 469 +fn c298_l469_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c298_l469_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000011754944 as f32, 0.000000000000000000000000000000000000011754942 as f32, &vm_context); + assert_eq!(result, 1.0000001 as f32); +} + +// Line 470 +fn c299_l470_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c299_l470_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000011754942 as f32, 0.000000000000000000000000000000000000011754944 as f32, &vm_context); + assert_eq!(result, 0.9999999 as f32); +} + +// Line 471 +fn c300_l471_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c300_l471_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64, &vm_context); + assert_eq!(result, 1.0000000000000002 as f64); +} + +// Line 472 +fn c301_l472_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c301_l472_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64, &vm_context); + assert_eq!(result, 0.9999999999999998 as f64); +} + +// Line 475 +fn c302_l475_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c302_l475_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000023841856 as f32, 340282350000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 0.0 as f32); +} + +// Line 476 +fn c303_l476_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c303_l476_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000023841858 as f32, 340282350000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000001 as f32); +} + +// Line 477 +fn c304_l477_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c304_l477_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000044408920985006257 as f64, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.0 as f64); +} + +// Line 478 +fn c305_l478_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c305_l478_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000004440892098500626 as f64, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64); +} + +// Line 481 +fn c306_l481_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c306_l481_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 0.000000000000000000000000000000000000002938736 as f32, &vm_context); + assert_eq!(result, std::f32::INFINITY); +} + +// Line 482 +fn c307_l482_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c307_l482_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 0.000000000000000000000000000000000000002938737 as f32, &vm_context); + assert_eq!(result, 340282200000000000000000000000000000000.0 as f32); +} + +// Line 483 +fn c308_l483_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c308_l483_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003 as f64, &vm_context); + assert_eq!(result, std::f64::INFINITY); +} + +// Line 484 +fn c309_l484_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c309_l484_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000556268464626801 as f64, &vm_context); + assert_eq!(result, 179769313486231430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 487 +fn c310_l487_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c310_l487_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 85070600000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000011754942 as f32); +} + +// Line 488 +fn c311_l488_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c311_l488_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 85070590000000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000011754944 as f32); +} + +// Line 489 +fn c312_l489_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c312_l489_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 44942328371557910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64); +} + +// Line 490 +fn c313_l490_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c313_l490_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64); +} + +// Line 500 +fn c314_l500_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c314_l500_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 3.0 as f32, &vm_context); + assert_eq!(result, 0.33333334 as f32); +} + +// Line 501 +fn c315_l501_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c315_l501_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(3.0 as f32, 9.0 as f32, &vm_context); + assert_eq!(result, 0.33333334 as f32); +} + +// Line 502 +fn c316_l502_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c316_l502_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9.0 as f32, 27.0 as f32, &vm_context); + assert_eq!(result, 0.33333334 as f32); +} + +// Line 503 +fn c317_l503_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c317_l503_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 3.0 as f64, &vm_context); + assert_eq!(result, 0.3333333333333333 as f64); +} + +// Line 504 +fn c318_l504_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c318_l504_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(3.0 as f64, 9.0 as f64, &vm_context); + assert_eq!(result, 0.3333333333333333 as f64); +} + +// Line 505 +fn c319_l505_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c319_l505_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9.0 as f64, 27.0 as f64, &vm_context); + assert_eq!(result, 0.3333333333333333 as f64); +} + +// Line 508 +fn c320_l508_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c320_l508_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000001 as f32, 0.99999994 as f32, &vm_context); + assert_eq!(result, 1.0000002 as f32); +} + +// Line 509 +fn c321_l509_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c321_l509_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.99999994 as f32, 1.0000001 as f32, &vm_context); + assert_eq!(result, 0.9999998 as f32); +} + +// Line 510 +fn c322_l510_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c322_l510_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 0.99999994 as f32, &vm_context); + assert_eq!(result, 1.0000001 as f32); +} + +// Line 511 +fn c323_l511_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c323_l511_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f32, 1.0000001 as f32, &vm_context); + assert_eq!(result, 0.9999999 as f32); +} + +// Line 512 +fn c324_l512_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c324_l512_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000002 as f64, 0.9999999999999999 as f64, &vm_context); + assert_eq!(result, 1.0000000000000004 as f64); +} + +// Line 513 +fn c325_l513_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c325_l513_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.9999999999999999 as f64, 1.0000000000000002 as f64, &vm_context); + assert_eq!(result, 0.9999999999999997 as f64); +} + +// Line 514 +fn c326_l514_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c326_l514_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 0.9999999999999999 as f64, &vm_context); + assert_eq!(result, 1.0000000000000002 as f64); +} + +// Line 515 +fn c327_l515_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c327_l515_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.div") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0 as f64, 1.0000000000000002 as f64, &vm_context); + assert_eq!(result, 0.9999999999999998 as f64); +} + +// Line 519 +fn c328_l519_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c328_l519_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(171.0 as f32, &vm_context); + assert_eq!(result, 13.076696 as f32); +} + +// Line 520 +fn c329_l520_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c329_l520_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000160795 as f32, &vm_context); + assert_eq!(result, 0.00040099252 as f32); +} + +// Line 521 +fn c330_l521_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c330_l521_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(171.0 as f64, &vm_context); + assert_eq!(result, 13.076696830622021 as f64); +} + +// Line 522 +fn c331_l522_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c331_l522_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000160795 as f64, &vm_context); + assert_eq!(result, 0.00040099251863345283 as f64); +} + +// Line 525 +fn c332_l525_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c332_l525_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000004316357580352844 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000020775845543209175 as f64); +} + +// Line 526 +fn c333_l526_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c333_l526_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(676253300479648500000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 822346216918183800000000000000000000000000000000000.0 as f64); +} + +// Line 527 +fn c334_l527_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c334_l527_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(17485296624861996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 4181542373916829400000000000000000000000000000000000000000000.0 as f64); +} + +// Line 528 +fn c335_l528_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c335_l528_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000009593720960603523 as f64, &vm_context); + assert_eq!(result, 0.0000030973732355987585 as f64); +} + +// Line 529 +fn c336_l529_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c336_l529_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006348452898717835 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000002519613640762773 as f64); +} + +// Line 533 +fn c337_l533_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c337_l533_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.9999999999999999 as f64, &vm_context); + assert_eq!(result, 0.9999999999999999 as f64); +} + +// Line 536 +fn c338_l536_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c338_l536_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.12963942 as f32, &vm_context); + assert_eq!(result, 0.36005473 as f32); +} + +// Line 537 +fn c339_l537_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c339_l537_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2345875800000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 1531625200000000.0 as f32); +} + +// Line 538 +fn c340_l538_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c340_l538_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.078786574 as f32, &vm_context); + assert_eq!(result, 0.28068945 as f32); +} + +// Line 539 +fn c341_l539_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c341_l539_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000051371026 as f32, &vm_context); + assert_eq!(result, 0.000000000022665177 as f32); +} + +// Line 540 +fn c342_l540_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c342_l540_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00090167153 as f32, &vm_context); + assert_eq!(result, 0.030027846 as f32); +} + +// Line 541 +fn c343_l541_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c343_l541_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009591922760825561 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009793836204892116 as f64); +} + +// Line 542 +fn c344_l542_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c344_l542_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(935787535216400500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 30590644570136150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 543 +fn c345_l543_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c345_l543_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(147706699783365580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 12153464517715332000000000000000000000000000000000000000000.0 as f64); +} + +// Line 544 +fn c346_l544_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c346_l544_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(48800457180027890000000000000000.0 as f64, &vm_context); + assert_eq!(result, 6985732401117859.0 as f64); +} + +// Line 545 +fn c347_l545_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c347_l545_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(7618977687174540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 2760249569726357000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 548 +fn c348_l548_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c348_l548_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(154481010.0 as f32, &vm_context); + assert_eq!(result, 12429.039 as f32); +} + +// Line 549 +fn c349_l549_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c349_l549_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000010471305 as f32, &vm_context); + assert_eq!(result, 0.00000000000000001023294 as f32); +} + +// Line 550 +fn c350_l550_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c350_l550_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00003790637 as f32, &vm_context); + assert_eq!(result, 0.006156815 as f32); +} + +// Line 551 +fn c351_l551_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c351_l551_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000089607535 as f32, &vm_context); + assert_eq!(result, 0.0000000000000000009466126 as f32); +} + +// Line 552 +fn c352_l552_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c352_l552_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000001687712 as f32, &vm_context); + assert_eq!(result, 0.00000000000000000041081773 as f32); +} + +// Line 553 +fn c353_l553_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c353_l553_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(316996264378909500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 563024212959717700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 554 +fn c354_l554_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c354_l554_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040573669271847993 as f64, &vm_context); + assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020142906759414837 as f64); +} + +// Line 555 +fn c355_l555_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c355_l555_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000015299861660588838 as f64, &vm_context); + assert_eq!(result, 0.00003911503759500793 as f64); +} + +// Line 556 +fn c356_l556_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c356_l556_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000002822766928951239 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000005312971794533864 as f64); +} + +// Line 557 +fn c357_l557_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c357_l557_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(14375957727045067000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 119899782014168260000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 560 +fn c358_l560_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c358_l560_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(464023420000000000000000000000000000.0 as f32, &vm_context); + assert_eq!(result, 681192700000000000.0 as f32); +} + +// Line 561 +fn c359_l561_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c359_l561_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(47536.133 as f32, &vm_context); + assert_eq!(result, 218.02783 as f32); +} + +// Line 562 +fn c360_l562_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c360_l562_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.812613 as f32, &vm_context); + assert_eq!(result, 0.9014505 as f32); +} + +// Line 563 +fn c361_l563_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c361_l563_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000009549605 as f32, &vm_context); + assert_eq!(result, 0.00000000000009772208 as f32); +} + +// Line 564 +fn c362_l564_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c362_l564_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000068856485 as f32, &vm_context); + assert_eq!(result, 0.000000000000008297981 as f32); +} + +// Line 565 +fn c363_l565_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c363_l565_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2349768917495332200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 1532895599020146000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 566 +fn c364_l566_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c364_l566_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029262574743429683 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000005409489323718985 as f64); +} + +// Line 567 +fn c365_l567_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c365_l567_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(377335087484490800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 19425114864126050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 568 +fn c366_l568_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c366_l568_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000035498432023945234 as f64, &vm_context); + assert_eq!(result, 0.00000018841027579180822 as f64); +} + +// Line 569 +fn c367_l569_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c367_l569_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013747419336166767 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000011724938949165905 as f64); +} + +// Line 572 + +// Line 573 +fn c369_l573_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c369_l573_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(18763296348029700000000000000000.0 as f64, &vm_context); + assert_eq!(result, 4331662076851067.0 as f64); +} + +// Line 574 +fn c370_l574_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c370_l574_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000274405777036165 as f64, &vm_context); + assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000523837548325972 as f64); +} + +// Line 575 +fn c371_l575_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c371_l575_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000015613859952920445 as f64, &vm_context); + assert_eq!(result, 0.0000000000000000000000000000000000000000039514377070783294 as f64); +} + +// Line 576 +fn c372_l576_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c372_l576_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(619303768945071200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context); + assert_eq!(result, 24885814612848646000000000000000000000000000000000000000000000000000000000000000000000.0 as f64); +} + +// Line 579 +fn c373_l579_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c373_l579_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000001 as f32, &vm_context); + assert_eq!(result, 1.0 as f32); +} + +// Line 580 +fn c374_l580_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c374_l580_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000002 as f32, &vm_context); + assert_eq!(result, 1.0000001 as f32); +} + +// Line 581 +fn c375_l581_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c375_l581_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000002 as f64, &vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 582 +fn c376_l582_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c376_l582_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000004 as f64, &vm_context); + assert_eq!(result, 1.0000000000000002 as f64); +} + +// Line 585 +fn c377_l585_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c377_l585_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.9999999 as f32, &vm_context); + assert_eq!(result, 0.99999994 as f32); +} + +// Line 586 +fn c378_l586_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c378_l586_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.9999998 as f32, &vm_context); + assert_eq!(result, 0.9999999 as f32); +} + +// Line 587 +fn c379_l587_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c379_l587_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.9999999999999998 as f64, &vm_context); + assert_eq!(result, 0.9999999999999999 as f64); +} + +// Line 588 +fn c380_l588_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c380_l588_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.sqrt") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.9999999999999997 as f64, &vm_context); + assert_eq!(result, 0.9999999999999998 as f64); +} + +// Line 592 +fn c381_l592_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c381_l592_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.abs") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(std::f32::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f32::NAN).is_sign_positive()); +} + +// Line 593 +fn c382_l593_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c382_l593_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.abs") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-std::f32::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f32::NAN).is_sign_positive()); +} + +// Line 594 +fn c383_l594_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c383_l594_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.abs") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(std::f64::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f64::NAN).is_sign_positive()); +} + +// Line 595 +fn c384_l595_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c384_l595_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.abs") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-std::f64::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f64::NAN).is_sign_positive()); +} + +// Line 597 +fn c385_l597_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c385_l597_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.neg") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(std::f32::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (-std::f32::NAN).is_sign_positive()); +} + +// Line 598 +fn c386_l598_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c386_l598_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.neg") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-std::f32::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f32::NAN).is_sign_positive()); +} + +// Line 599 +fn c387_l599_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c387_l599_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.neg") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(std::f64::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (-std::f64::NAN).is_sign_positive()); +} + +// Line 600 +fn c388_l600_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c388_l600_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.neg") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-std::f64::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f64::NAN).is_sign_positive()); +} + +// Line 602 +fn c389_l602_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c389_l602_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.copysign") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(std::f32::NAN, std::f32::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f32::NAN).is_sign_positive()); +} + +// Line 603 +fn c390_l603_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c390_l603_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.copysign") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(std::f32::NAN, -std::f32::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (-std::f32::NAN).is_sign_positive()); +} + +// Line 604 +fn c391_l604_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c391_l604_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.copysign") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-std::f32::NAN, std::f32::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f32::NAN).is_sign_positive()); +} + +// Line 605 +fn c392_l605_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c392_l605_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.copysign") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-std::f32::NAN, -std::f32::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (-std::f32::NAN).is_sign_positive()); +} + +// Line 606 +fn c393_l606_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c393_l606_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.copysign") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(std::f64::NAN, std::f64::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f64::NAN).is_sign_positive()); +} + +// Line 607 +fn c394_l607_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c394_l607_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.copysign") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(std::f64::NAN, -std::f64::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (-std::f64::NAN).is_sign_positive()); +} + +// Line 608 +fn c395_l608_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c395_l608_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.copysign") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-std::f64::NAN, std::f64::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (std::f64::NAN).is_sign_positive()); +} + +// Line 609 +fn c396_l609_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c396_l609_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.copysign") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-std::f64::NAN, -std::f64::NAN, &vm_context); + assert!(result.is_nan()); + assert_eq!(result.is_sign_positive(), (-std::f64::NAN).is_sign_positive()); +} + +// Line 612 +fn c397_l612_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c397_l612_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.99999994 as f32, &vm_context); + assert_eq!(result, 1.0 as f32); +} + +// Line 613 +fn c398_l613_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c398_l613_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000001 as f32, &vm_context); + assert_eq!(result, 2.0 as f32); +} + +// Line 614 +fn c399_l614_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c399_l614_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.9999999999999999 as f64, &vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 615 +fn c400_l615_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c400_l615_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1.0000000000000002 as f64, &vm_context); + assert_eq!(result, 2.0 as f64); +} + +// Line 618 +fn c401_l618_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c401_l618_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8388607.5 as f32, &vm_context); + assert_eq!(result, 8388608.0 as f32); +} + +// Line 619 +fn c402_l619_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c402_l619_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-8388607.5 as f32, &vm_context); + assert_eq!(result, -8388607.0 as f32); +} + +// Line 620 +fn c403_l620_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c403_l620_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4503599627370495.5 as f64, &vm_context); + assert_eq!(result, 4503599627370496.0 as f64); +} + +// Line 621 +fn c404_l621_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c404_l621_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4503599627370495.5 as f64, &vm_context); + assert_eq!(result, -4503599627370495.0 as f64); +} + +// Line 625 +fn c405_l625_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c405_l625_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(16777215.0 as f32, &vm_context); + assert_eq!(result, 16777215.0 as f32); +} + +// Line 626 +fn c406_l626_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c406_l626_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-16777215.0 as f32, &vm_context); + assert_eq!(result, -16777215.0 as f32); +} + +// Line 627 +fn c407_l627_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c407_l627_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9007199254740991.0 as f64, &vm_context); + assert_eq!(result, 9007199254740991.0 as f64); +} + +// Line 628 +fn c408_l628_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c408_l628_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.ceil") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-9007199254740991.0 as f64, &vm_context); + assert_eq!(result, -9007199254740991.0 as f64); +} + +// Line 631 +fn c409_l631_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c409_l631_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.99999994 as f32, &vm_context); + assert_eq!(result, -1.0 as f32); +} + +// Line 632 +fn c410_l632_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c410_l632_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1.0000001 as f32, &vm_context); + assert_eq!(result, -2.0 as f32); +} + +// Line 633 +fn c411_l633_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c411_l633_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-0.9999999999999999 as f64, &vm_context); + assert_eq!(result, -1.0 as f64); +} + +// Line 634 +fn c412_l634_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c412_l634_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1.0000000000000002 as f64, &vm_context); + assert_eq!(result, -2.0 as f64); +} + +// Line 637 +fn c413_l637_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c413_l637_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-8388607.5 as f32, &vm_context); + assert_eq!(result, -8388608.0 as f32); +} + +// Line 638 +fn c414_l638_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c414_l638_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8388607.5 as f32, &vm_context); + assert_eq!(result, 8388607.0 as f32); +} + +// Line 639 +fn c415_l639_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c415_l639_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4503599627370495.5 as f64, &vm_context); + assert_eq!(result, -4503599627370496.0 as f64); +} + +// Line 640 +fn c416_l640_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c416_l640_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4503599627370495.5 as f64, &vm_context); + assert_eq!(result, 4503599627370495.0 as f64); +} + +// Line 644 +fn c417_l644_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c417_l644_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(88607.0 as f32, &vm_context); + assert_eq!(result, 88607.0 as f32); +} + +// Line 645 +fn c418_l645_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c418_l645_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.floor") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(88607.0 as f64, &vm_context); + assert_eq!(result, 88607.0 as f64); +} + +// Line 648 +fn c419_l648_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c419_l648_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.trunc") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-8388607.5 as f32, &vm_context); + assert_eq!(result, -8388607.0 as f32); +} + +// Line 649 +fn c420_l649_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c420_l649_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.trunc") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8388607.5 as f32, &vm_context); + assert_eq!(result, 8388607.0 as f32); +} + +// Line 650 +fn c421_l650_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c421_l650_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.trunc") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4503599627370495.5 as f64, &vm_context); + assert_eq!(result, -4503599627370495.0 as f64); +} + +// Line 651 +fn c422_l651_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c422_l651_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.trunc") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4503599627370495.5 as f64, &vm_context); + assert_eq!(result, 4503599627370495.0 as f64); +} + +// Line 656 +fn c423_l656_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c423_l656_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8388609.0 as f32, &vm_context); + assert_eq!(result, 8388609.0 as f32); +} + +// Line 657 +fn c424_l657_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c424_l657_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8388610.0 as f32, &vm_context); + assert_eq!(result, 8388610.0 as f32); +} + +// Line 658 +fn c425_l658_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c425_l658_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.49999997 as f32, &vm_context); + assert_eq!(result, 0.0 as f32); +} + +// Line 659 +fn c426_l659_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c426_l659_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(281474960000000.0 as f32, &vm_context); + assert_eq!(result, 281474960000000.0 as f32); +} + +// Line 660 +fn c427_l660_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c427_l660_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4503599627370497.0 as f64, &vm_context); + assert_eq!(result, 4503599627370497.0 as f64); +} + +// Line 661 +fn c428_l661_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c428_l661_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4503599627370498.0 as f64, &vm_context); + assert_eq!(result, 4503599627370498.0 as f64); +} + +// Line 662 +fn c429_l662_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c429_l662_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0.49999999999999994 as f64, &vm_context); + assert_eq!(result, 0.0 as f64); +} + +// Line 663 +fn c430_l663_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c430_l663_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(81129638414606670000000000000000.0 as f64, &vm_context); + assert_eq!(result, 81129638414606670000000000000000.0 as f64); +} + +// Line 667 +fn c431_l667_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c431_l667_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4.5 as f32, &vm_context); + assert_eq!(result, 4.0 as f32); +} + +// Line 668 +fn c432_l668_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c432_l668_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4.5 as f32, &vm_context); + assert_eq!(result, -4.0 as f32); +} + +// Line 669 +fn c433_l669_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c433_l669_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-3.5 as f32, &vm_context); + assert_eq!(result, -4.0 as f32); +} + +// Line 670 +fn c434_l670_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c434_l670_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4.5 as f64, &vm_context); + assert_eq!(result, 4.0 as f64); +} + +// Line 671 +fn c435_l671_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c435_l671_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4.5 as f64, &vm_context); + assert_eq!(result, -4.0 as f64); +} + +// Line 672 +fn c436_l672_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c436_l672_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-3.5 as f64, &vm_context); + assert_eq!(result, -4.0 as f64); +} + +// Line 675 +fn c437_l675_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c437_l675_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-8388607.5 as f32, &vm_context); + assert_eq!(result, -8388608.0 as f32); +} + +// Line 676 +fn c438_l676_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c438_l676_action_invoke"); + let func_index = match result_object.module.info.exports.get("f32.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(8388607.5 as f32, &vm_context); + assert_eq!(result, 8388608.0 as f32); +} + +// Line 677 +fn c439_l677_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c439_l677_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-4503599627370495.5 as f64, &vm_context); + assert_eq!(result, -4503599627370496.0 as f64); +} + +// Line 678 +fn c440_l678_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "c440_l678_action_invoke"); + let func_index = match result_object.module.info.exports.get("f64.nearest") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(4503599627370495.5 as f64, &vm_context); + assert_eq!(result, 4503599627370496.0 as f64); +} + +#[test] +fn test_module_1() { + let result_object = create_module_1(); + let vm_context = result_object.instance.generate_context(); + // We group the calls together + start_module_1(&result_object, &vm_context); + c1_l50_action_invoke(&result_object, &vm_context); + c2_l51_action_invoke(&result_object, &vm_context); + c3_l55_action_invoke(&result_object, &vm_context); + c4_l56_action_invoke(&result_object, &vm_context); + c5_l57_action_invoke(&result_object, &vm_context); + c6_l58_action_invoke(&result_object, &vm_context); + c7_l61_action_invoke(&result_object, &vm_context); + c8_l62_action_invoke(&result_object, &vm_context); + c9_l67_action_invoke(&result_object, &vm_context); + c10_l68_action_invoke(&result_object, &vm_context); + c11_l72_action_invoke(&result_object, &vm_context); + c12_l75_action_invoke(&result_object, &vm_context); + c13_l78_action_invoke(&result_object, &vm_context); + c14_l81_action_invoke(&result_object, &vm_context); + c15_l82_action_invoke(&result_object, &vm_context); + c16_l83_action_invoke(&result_object, &vm_context); + c17_l84_action_invoke(&result_object, &vm_context); + c18_l87_action_invoke(&result_object, &vm_context); + c19_l88_action_invoke(&result_object, &vm_context); + c20_l89_action_invoke(&result_object, &vm_context); + c21_l90_action_invoke(&result_object, &vm_context); + c22_l91_action_invoke(&result_object, &vm_context); + c23_l92_action_invoke(&result_object, &vm_context); + c24_l93_action_invoke(&result_object, &vm_context); + c25_l94_action_invoke(&result_object, &vm_context); + c26_l95_action_invoke(&result_object, &vm_context); + c27_l96_action_invoke(&result_object, &vm_context); + c28_l99_action_invoke(&result_object, &vm_context); + c29_l100_action_invoke(&result_object, &vm_context); + c30_l101_action_invoke(&result_object, &vm_context); + c31_l102_action_invoke(&result_object, &vm_context); + c32_l103_action_invoke(&result_object, &vm_context); + c33_l104_action_invoke(&result_object, &vm_context); + c34_l105_action_invoke(&result_object, &vm_context); + c35_l106_action_invoke(&result_object, &vm_context); + c36_l107_action_invoke(&result_object, &vm_context); + c37_l108_action_invoke(&result_object, &vm_context); + c38_l111_action_invoke(&result_object, &vm_context); + c39_l112_action_invoke(&result_object, &vm_context); + c40_l113_action_invoke(&result_object, &vm_context); + c41_l114_action_invoke(&result_object, &vm_context); + c42_l115_action_invoke(&result_object, &vm_context); + c43_l116_action_invoke(&result_object, &vm_context); + c44_l117_action_invoke(&result_object, &vm_context); + c45_l118_action_invoke(&result_object, &vm_context); + c46_l119_action_invoke(&result_object, &vm_context); + c47_l120_action_invoke(&result_object, &vm_context); + c48_l123_action_invoke(&result_object, &vm_context); + c49_l124_action_invoke(&result_object, &vm_context); + c50_l125_action_invoke(&result_object, &vm_context); + c51_l126_action_invoke(&result_object, &vm_context); + c52_l127_action_invoke(&result_object, &vm_context); + c53_l130_action_invoke(&result_object, &vm_context); + c54_l131_action_invoke(&result_object, &vm_context); + c55_l132_action_invoke(&result_object, &vm_context); + c56_l133_action_invoke(&result_object, &vm_context); + c57_l134_action_invoke(&result_object, &vm_context); + c58_l137_action_invoke(&result_object, &vm_context); + c59_l138_action_invoke(&result_object, &vm_context); + c60_l139_action_invoke(&result_object, &vm_context); + c61_l140_action_invoke(&result_object, &vm_context); + c62_l141_action_invoke(&result_object, &vm_context); + c63_l142_action_invoke(&result_object, &vm_context); + c64_l143_action_invoke(&result_object, &vm_context); + c65_l144_action_invoke(&result_object, &vm_context); + c66_l145_action_invoke(&result_object, &vm_context); + c67_l146_action_invoke(&result_object, &vm_context); + c68_l149_action_invoke(&result_object, &vm_context); + c69_l150_action_invoke(&result_object, &vm_context); + c70_l151_action_invoke(&result_object, &vm_context); + c71_l152_action_invoke(&result_object, &vm_context); + c72_l153_action_invoke(&result_object, &vm_context); + c73_l154_action_invoke(&result_object, &vm_context); + c74_l155_action_invoke(&result_object, &vm_context); + c75_l156_action_invoke(&result_object, &vm_context); + c76_l157_action_invoke(&result_object, &vm_context); + c77_l158_action_invoke(&result_object, &vm_context); + c78_l162_action_invoke(&result_object, &vm_context); + c79_l163_action_invoke(&result_object, &vm_context); + c80_l166_action_invoke(&result_object, &vm_context); + c81_l167_action_invoke(&result_object, &vm_context); + c82_l170_action_invoke(&result_object, &vm_context); + c83_l171_action_invoke(&result_object, &vm_context); + c84_l172_action_invoke(&result_object, &vm_context); + c85_l173_action_invoke(&result_object, &vm_context); + c86_l177_action_invoke(&result_object, &vm_context); + c87_l178_action_invoke(&result_object, &vm_context); + c88_l182_action_invoke(&result_object, &vm_context); + c89_l183_action_invoke(&result_object, &vm_context); + c90_l184_action_invoke(&result_object, &vm_context); + c91_l185_action_invoke(&result_object, &vm_context); + c92_l188_action_invoke(&result_object, &vm_context); + c93_l189_action_invoke(&result_object, &vm_context); + c94_l190_action_invoke(&result_object, &vm_context); + c95_l191_action_invoke(&result_object, &vm_context); + c96_l192_action_invoke(&result_object, &vm_context); + c97_l193_action_invoke(&result_object, &vm_context); + c98_l194_action_invoke(&result_object, &vm_context); + c99_l195_action_invoke(&result_object, &vm_context); + c100_l196_action_invoke(&result_object, &vm_context); + c101_l197_action_invoke(&result_object, &vm_context); + c102_l200_action_invoke(&result_object, &vm_context); + c103_l201_action_invoke(&result_object, &vm_context); + c104_l202_action_invoke(&result_object, &vm_context); + c105_l203_action_invoke(&result_object, &vm_context); + c106_l204_action_invoke(&result_object, &vm_context); + c107_l205_action_invoke(&result_object, &vm_context); + c108_l206_action_invoke(&result_object, &vm_context); + c109_l207_action_invoke(&result_object, &vm_context); + c110_l208_action_invoke(&result_object, &vm_context); + c111_l209_action_invoke(&result_object, &vm_context); + c112_l212_action_invoke(&result_object, &vm_context); + c113_l213_action_invoke(&result_object, &vm_context); + c114_l214_action_invoke(&result_object, &vm_context); + c115_l215_action_invoke(&result_object, &vm_context); + c116_l216_action_invoke(&result_object, &vm_context); + c117_l217_action_invoke(&result_object, &vm_context); + c118_l218_action_invoke(&result_object, &vm_context); + c119_l219_action_invoke(&result_object, &vm_context); + c120_l220_action_invoke(&result_object, &vm_context); + c121_l221_action_invoke(&result_object, &vm_context); + c122_l224_action_invoke(&result_object, &vm_context); + c123_l225_action_invoke(&result_object, &vm_context); + c124_l226_action_invoke(&result_object, &vm_context); + c125_l227_action_invoke(&result_object, &vm_context); + c126_l228_action_invoke(&result_object, &vm_context); + c127_l231_action_invoke(&result_object, &vm_context); + c128_l232_action_invoke(&result_object, &vm_context); + c129_l233_action_invoke(&result_object, &vm_context); + c130_l234_action_invoke(&result_object, &vm_context); + c131_l235_action_invoke(&result_object, &vm_context); + c132_l239_action_invoke(&result_object, &vm_context); + c133_l240_action_invoke(&result_object, &vm_context); + c134_l243_action_invoke(&result_object, &vm_context); + c135_l244_action_invoke(&result_object, &vm_context); + c136_l245_action_invoke(&result_object, &vm_context); + c137_l246_action_invoke(&result_object, &vm_context); + c138_l247_action_invoke(&result_object, &vm_context); + c139_l248_action_invoke(&result_object, &vm_context); + c140_l249_action_invoke(&result_object, &vm_context); + c141_l250_action_invoke(&result_object, &vm_context); + c142_l251_action_invoke(&result_object, &vm_context); + c143_l252_action_invoke(&result_object, &vm_context); + c144_l255_action_invoke(&result_object, &vm_context); + c145_l256_action_invoke(&result_object, &vm_context); + c146_l259_action_invoke(&result_object, &vm_context); + c147_l260_action_invoke(&result_object, &vm_context); + c148_l261_action_invoke(&result_object, &vm_context); + c149_l262_action_invoke(&result_object, &vm_context); + c150_l263_action_invoke(&result_object, &vm_context); + c151_l264_action_invoke(&result_object, &vm_context); + c152_l268_action_invoke(&result_object, &vm_context); + c153_l269_action_invoke(&result_object, &vm_context); + c154_l270_action_invoke(&result_object, &vm_context); + c155_l271_action_invoke(&result_object, &vm_context); + c156_l274_action_invoke(&result_object, &vm_context); + c157_l275_action_invoke(&result_object, &vm_context); + c158_l276_action_invoke(&result_object, &vm_context); + c159_l277_action_invoke(&result_object, &vm_context); + c160_l278_action_invoke(&result_object, &vm_context); + c161_l279_action_invoke(&result_object, &vm_context); + c162_l284_action_invoke(&result_object, &vm_context); + c163_l285_action_invoke(&result_object, &vm_context); + c164_l289_action_invoke(&result_object, &vm_context); + c165_l290_action_invoke(&result_object, &vm_context); + c166_l293_action_invoke(&result_object, &vm_context); + c167_l294_action_invoke(&result_object, &vm_context); + c168_l295_action_invoke(&result_object, &vm_context); + c169_l296_action_invoke(&result_object, &vm_context); + c170_l297_action_invoke(&result_object, &vm_context); + c171_l298_action_invoke(&result_object, &vm_context); + c172_l299_action_invoke(&result_object, &vm_context); + c173_l300_action_invoke(&result_object, &vm_context); + c174_l301_action_invoke(&result_object, &vm_context); + c175_l302_action_invoke(&result_object, &vm_context); + c176_l305_action_invoke(&result_object, &vm_context); + c177_l306_action_invoke(&result_object, &vm_context); + c178_l307_action_invoke(&result_object, &vm_context); + c179_l308_action_invoke(&result_object, &vm_context); + c180_l309_action_invoke(&result_object, &vm_context); + c181_l310_action_invoke(&result_object, &vm_context); + c182_l311_action_invoke(&result_object, &vm_context); + c183_l312_action_invoke(&result_object, &vm_context); + c184_l313_action_invoke(&result_object, &vm_context); + c185_l314_action_invoke(&result_object, &vm_context); + c186_l317_action_invoke(&result_object, &vm_context); + c187_l318_action_invoke(&result_object, &vm_context); + c188_l319_action_invoke(&result_object, &vm_context); + c189_l320_action_invoke(&result_object, &vm_context); + c190_l321_action_invoke(&result_object, &vm_context); + c191_l322_action_invoke(&result_object, &vm_context); + c192_l323_action_invoke(&result_object, &vm_context); + c193_l324_action_invoke(&result_object, &vm_context); + c194_l325_action_invoke(&result_object, &vm_context); + c195_l326_action_invoke(&result_object, &vm_context); + c196_l329_action_invoke(&result_object, &vm_context); + c197_l330_action_invoke(&result_object, &vm_context); + c198_l331_action_invoke(&result_object, &vm_context); + c199_l332_action_invoke(&result_object, &vm_context); + c200_l333_action_invoke(&result_object, &vm_context); + c201_l336_action_invoke(&result_object, &vm_context); + c202_l337_action_invoke(&result_object, &vm_context); + c203_l338_action_invoke(&result_object, &vm_context); + c204_l339_action_invoke(&result_object, &vm_context); + c205_l340_action_invoke(&result_object, &vm_context); + c206_l343_action_invoke(&result_object, &vm_context); + c207_l344_action_invoke(&result_object, &vm_context); + c208_l345_action_invoke(&result_object, &vm_context); + c209_l346_action_invoke(&result_object, &vm_context); + c210_l347_action_invoke(&result_object, &vm_context); + c211_l350_action_invoke(&result_object, &vm_context); + c212_l351_action_invoke(&result_object, &vm_context); + c213_l352_action_invoke(&result_object, &vm_context); + c214_l353_action_invoke(&result_object, &vm_context); + c215_l356_action_invoke(&result_object, &vm_context); + c216_l357_action_invoke(&result_object, &vm_context); + c217_l358_action_invoke(&result_object, &vm_context); + c218_l359_action_invoke(&result_object, &vm_context); + c219_l362_action_invoke(&result_object, &vm_context); + c220_l363_action_invoke(&result_object, &vm_context); + c221_l364_action_invoke(&result_object, &vm_context); + c222_l365_action_invoke(&result_object, &vm_context); + c223_l368_action_invoke(&result_object, &vm_context); + c224_l369_action_invoke(&result_object, &vm_context); + c225_l370_action_invoke(&result_object, &vm_context); + c226_l371_action_invoke(&result_object, &vm_context); + c227_l375_action_invoke(&result_object, &vm_context); + c228_l376_action_invoke(&result_object, &vm_context); + c229_l379_action_invoke(&result_object, &vm_context); + c230_l382_action_invoke(&result_object, &vm_context); + c231_l383_action_invoke(&result_object, &vm_context); + c232_l384_action_invoke(&result_object, &vm_context); + c233_l385_action_invoke(&result_object, &vm_context); + c234_l386_action_invoke(&result_object, &vm_context); + c235_l387_action_invoke(&result_object, &vm_context); + c236_l388_action_invoke(&result_object, &vm_context); + c237_l389_action_invoke(&result_object, &vm_context); + c238_l390_action_invoke(&result_object, &vm_context); + c239_l391_action_invoke(&result_object, &vm_context); + c240_l395_action_invoke(&result_object, &vm_context); + c241_l396_action_invoke(&result_object, &vm_context); + c242_l399_action_invoke(&result_object, &vm_context); + c243_l400_action_invoke(&result_object, &vm_context); + c244_l401_action_invoke(&result_object, &vm_context); + c245_l402_action_invoke(&result_object, &vm_context); + c246_l403_action_invoke(&result_object, &vm_context); + c247_l404_action_invoke(&result_object, &vm_context); + c248_l405_action_invoke(&result_object, &vm_context); + c249_l406_action_invoke(&result_object, &vm_context); + c250_l407_action_invoke(&result_object, &vm_context); + c251_l408_action_invoke(&result_object, &vm_context); + c252_l411_action_invoke(&result_object, &vm_context); + c253_l412_action_invoke(&result_object, &vm_context); + c254_l413_action_invoke(&result_object, &vm_context); + c255_l414_action_invoke(&result_object, &vm_context); + c256_l415_action_invoke(&result_object, &vm_context); + c257_l416_action_invoke(&result_object, &vm_context); + c258_l417_action_invoke(&result_object, &vm_context); + c259_l418_action_invoke(&result_object, &vm_context); + c260_l419_action_invoke(&result_object, &vm_context); + c261_l420_action_invoke(&result_object, &vm_context); + c262_l423_action_invoke(&result_object, &vm_context); + c263_l424_action_invoke(&result_object, &vm_context); + c264_l425_action_invoke(&result_object, &vm_context); + c265_l426_action_invoke(&result_object, &vm_context); + c266_l427_action_invoke(&result_object, &vm_context); + c267_l428_action_invoke(&result_object, &vm_context); + c268_l429_action_invoke(&result_object, &vm_context); + c269_l430_action_invoke(&result_object, &vm_context); + c270_l431_action_invoke(&result_object, &vm_context); + c271_l432_action_invoke(&result_object, &vm_context); + c272_l435_action_invoke(&result_object, &vm_context); + c273_l436_action_invoke(&result_object, &vm_context); + c274_l437_action_invoke(&result_object, &vm_context); + c275_l438_action_invoke(&result_object, &vm_context); + c276_l439_action_invoke(&result_object, &vm_context); + c277_l442_action_invoke(&result_object, &vm_context); + c278_l443_action_invoke(&result_object, &vm_context); + c279_l444_action_invoke(&result_object, &vm_context); + c280_l445_action_invoke(&result_object, &vm_context); + c281_l446_action_invoke(&result_object, &vm_context); + c282_l447_action_invoke(&result_object, &vm_context); + c283_l450_action_invoke(&result_object, &vm_context); + c284_l451_action_invoke(&result_object, &vm_context); + c285_l452_action_invoke(&result_object, &vm_context); + c286_l453_action_invoke(&result_object, &vm_context); + c287_l454_action_invoke(&result_object, &vm_context); + c288_l455_action_invoke(&result_object, &vm_context); + c289_l456_action_invoke(&result_object, &vm_context); + c290_l457_action_invoke(&result_object, &vm_context); + c291_l458_action_invoke(&result_object, &vm_context); + c292_l459_action_invoke(&result_object, &vm_context); + c293_l462_action_invoke(&result_object, &vm_context); + c294_l463_action_invoke(&result_object, &vm_context); + c295_l464_action_invoke(&result_object, &vm_context); + c296_l465_action_invoke(&result_object, &vm_context); + c297_l466_action_invoke(&result_object, &vm_context); + c298_l469_action_invoke(&result_object, &vm_context); + c299_l470_action_invoke(&result_object, &vm_context); + c300_l471_action_invoke(&result_object, &vm_context); + c301_l472_action_invoke(&result_object, &vm_context); + c302_l475_action_invoke(&result_object, &vm_context); + c303_l476_action_invoke(&result_object, &vm_context); + c304_l477_action_invoke(&result_object, &vm_context); + c305_l478_action_invoke(&result_object, &vm_context); + c306_l481_action_invoke(&result_object, &vm_context); + c307_l482_action_invoke(&result_object, &vm_context); + c308_l483_action_invoke(&result_object, &vm_context); + c309_l484_action_invoke(&result_object, &vm_context); + c310_l487_action_invoke(&result_object, &vm_context); + c311_l488_action_invoke(&result_object, &vm_context); + c312_l489_action_invoke(&result_object, &vm_context); + c313_l490_action_invoke(&result_object, &vm_context); + c314_l500_action_invoke(&result_object, &vm_context); + c315_l501_action_invoke(&result_object, &vm_context); + c316_l502_action_invoke(&result_object, &vm_context); + c317_l503_action_invoke(&result_object, &vm_context); + c318_l504_action_invoke(&result_object, &vm_context); + c319_l505_action_invoke(&result_object, &vm_context); + c320_l508_action_invoke(&result_object, &vm_context); + c321_l509_action_invoke(&result_object, &vm_context); + c322_l510_action_invoke(&result_object, &vm_context); + c323_l511_action_invoke(&result_object, &vm_context); + c324_l512_action_invoke(&result_object, &vm_context); + c325_l513_action_invoke(&result_object, &vm_context); + c326_l514_action_invoke(&result_object, &vm_context); + c327_l515_action_invoke(&result_object, &vm_context); + c328_l519_action_invoke(&result_object, &vm_context); + c329_l520_action_invoke(&result_object, &vm_context); + c330_l521_action_invoke(&result_object, &vm_context); + c331_l522_action_invoke(&result_object, &vm_context); + c332_l525_action_invoke(&result_object, &vm_context); + c333_l526_action_invoke(&result_object, &vm_context); + c334_l527_action_invoke(&result_object, &vm_context); + c335_l528_action_invoke(&result_object, &vm_context); + c336_l529_action_invoke(&result_object, &vm_context); + c337_l533_action_invoke(&result_object, &vm_context); + c338_l536_action_invoke(&result_object, &vm_context); + c339_l537_action_invoke(&result_object, &vm_context); + c340_l538_action_invoke(&result_object, &vm_context); + c341_l539_action_invoke(&result_object, &vm_context); + c342_l540_action_invoke(&result_object, &vm_context); + c343_l541_action_invoke(&result_object, &vm_context); + c344_l542_action_invoke(&result_object, &vm_context); + c345_l543_action_invoke(&result_object, &vm_context); + c346_l544_action_invoke(&result_object, &vm_context); + c347_l545_action_invoke(&result_object, &vm_context); + c348_l548_action_invoke(&result_object, &vm_context); + c349_l549_action_invoke(&result_object, &vm_context); + c350_l550_action_invoke(&result_object, &vm_context); + c351_l551_action_invoke(&result_object, &vm_context); + c352_l552_action_invoke(&result_object, &vm_context); + c353_l553_action_invoke(&result_object, &vm_context); + c354_l554_action_invoke(&result_object, &vm_context); + c355_l555_action_invoke(&result_object, &vm_context); + c356_l556_action_invoke(&result_object, &vm_context); + c357_l557_action_invoke(&result_object, &vm_context); + c358_l560_action_invoke(&result_object, &vm_context); + c359_l561_action_invoke(&result_object, &vm_context); + c360_l562_action_invoke(&result_object, &vm_context); + c361_l563_action_invoke(&result_object, &vm_context); + c362_l564_action_invoke(&result_object, &vm_context); + c363_l565_action_invoke(&result_object, &vm_context); + c364_l566_action_invoke(&result_object, &vm_context); + c365_l567_action_invoke(&result_object, &vm_context); + c366_l568_action_invoke(&result_object, &vm_context); + c367_l569_action_invoke(&result_object, &vm_context); + c369_l573_action_invoke(&result_object, &vm_context); + c370_l574_action_invoke(&result_object, &vm_context); + c371_l575_action_invoke(&result_object, &vm_context); + c372_l576_action_invoke(&result_object, &vm_context); + c373_l579_action_invoke(&result_object, &vm_context); + c374_l580_action_invoke(&result_object, &vm_context); + c375_l581_action_invoke(&result_object, &vm_context); + c376_l582_action_invoke(&result_object, &vm_context); + c377_l585_action_invoke(&result_object, &vm_context); + c378_l586_action_invoke(&result_object, &vm_context); + c379_l587_action_invoke(&result_object, &vm_context); + c380_l588_action_invoke(&result_object, &vm_context); + c381_l592_action_invoke(&result_object, &vm_context); + c382_l593_action_invoke(&result_object, &vm_context); + c383_l594_action_invoke(&result_object, &vm_context); + c384_l595_action_invoke(&result_object, &vm_context); + c385_l597_action_invoke(&result_object, &vm_context); + c386_l598_action_invoke(&result_object, &vm_context); + c387_l599_action_invoke(&result_object, &vm_context); + c388_l600_action_invoke(&result_object, &vm_context); + c389_l602_action_invoke(&result_object, &vm_context); + c390_l603_action_invoke(&result_object, &vm_context); + c391_l604_action_invoke(&result_object, &vm_context); + c392_l605_action_invoke(&result_object, &vm_context); + c393_l606_action_invoke(&result_object, &vm_context); + c394_l607_action_invoke(&result_object, &vm_context); + c395_l608_action_invoke(&result_object, &vm_context); + c396_l609_action_invoke(&result_object, &vm_context); + c397_l612_action_invoke(&result_object, &vm_context); + c398_l613_action_invoke(&result_object, &vm_context); + c399_l614_action_invoke(&result_object, &vm_context); + c400_l615_action_invoke(&result_object, &vm_context); + c401_l618_action_invoke(&result_object, &vm_context); + c402_l619_action_invoke(&result_object, &vm_context); + c403_l620_action_invoke(&result_object, &vm_context); + c404_l621_action_invoke(&result_object, &vm_context); + c405_l625_action_invoke(&result_object, &vm_context); + c406_l626_action_invoke(&result_object, &vm_context); + c407_l627_action_invoke(&result_object, &vm_context); + c408_l628_action_invoke(&result_object, &vm_context); + c409_l631_action_invoke(&result_object, &vm_context); + c410_l632_action_invoke(&result_object, &vm_context); + c411_l633_action_invoke(&result_object, &vm_context); + c412_l634_action_invoke(&result_object, &vm_context); + c413_l637_action_invoke(&result_object, &vm_context); + c414_l638_action_invoke(&result_object, &vm_context); + c415_l639_action_invoke(&result_object, &vm_context); + c416_l640_action_invoke(&result_object, &vm_context); + c417_l644_action_invoke(&result_object, &vm_context); + c418_l645_action_invoke(&result_object, &vm_context); + c419_l648_action_invoke(&result_object, &vm_context); + c420_l649_action_invoke(&result_object, &vm_context); + c421_l650_action_invoke(&result_object, &vm_context); + c422_l651_action_invoke(&result_object, &vm_context); + c423_l656_action_invoke(&result_object, &vm_context); + c424_l657_action_invoke(&result_object, &vm_context); + c425_l658_action_invoke(&result_object, &vm_context); + c426_l659_action_invoke(&result_object, &vm_context); + c427_l660_action_invoke(&result_object, &vm_context); + c428_l661_action_invoke(&result_object, &vm_context); + c429_l662_action_invoke(&result_object, &vm_context); + c430_l663_action_invoke(&result_object, &vm_context); + c431_l667_action_invoke(&result_object, &vm_context); + c432_l668_action_invoke(&result_object, &vm_context); + c433_l669_action_invoke(&result_object, &vm_context); + c434_l670_action_invoke(&result_object, &vm_context); + c435_l671_action_invoke(&result_object, &vm_context); + c436_l672_action_invoke(&result_object, &vm_context); + c437_l675_action_invoke(&result_object, &vm_context); + c438_l676_action_invoke(&result_object, &vm_context); + c439_l677_action_invoke(&result_object, &vm_context); + c440_l678_action_invoke(&result_object, &vm_context); +} diff --git a/src/spectests/mod.rs b/src/spectests/mod.rs index 56e751b73..b8c9530a6 100644 --- a/src/spectests/mod.rs +++ b/src/spectests/mod.rs @@ -30,6 +30,7 @@ mod fac; mod float_exprs; mod float_literals; mod float_memory; +mod float_misc; mod func; mod func_ptrs; mod get_local;