diff --git a/test/Todo.md b/test/Todo.md
index cb7d711d2b..b98f989ec4 100644
--- a/test/Todo.md
+++ b/test/Todo.md
@@ -35,6 +35,7 @@ Threads (post-MVP):
    (is this possible?)
  - test that isLockFree is true for datatypes that the spec says should
    always be lock-free
+ - test that 16-bit and 8-bit cmpxchg does a wrapped 8-bit or 16-bit compare
 
 FMA (post-MVP):
  - http://www.vinc17.org/software/fma-tests.c
diff --git a/test/core/conversions.wast b/test/core/conversions.wast
index af178dc44b..e3c49b5de1 100644
--- a/test/core/conversions.wast
+++ b/test/core/conversions.wast
@@ -72,6 +72,9 @@
 (assert_trap (invoke "i32.trunc_s_f32" (f32.const infinity)) "integer overflow")
 (assert_trap (invoke "i32.trunc_s_f32" (f32.const -infinity)) "integer overflow")
 (assert_trap (invoke "i32.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_s_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
 
 (assert_return (invoke "i32.trunc_u_f32" (f32.const 0.0)) (i32.const 0))
 (assert_return (invoke "i32.trunc_u_f32" (f32.const -0.0)) (i32.const 0))
@@ -91,6 +94,9 @@
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const infinity)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const -infinity)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_u_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
 
 (assert_return (invoke "i32.trunc_s_f64" (f64.const 0.0)) (i32.const 0))
 (assert_return (invoke "i32.trunc_s_f64" (f64.const -0.0)) (i32.const 0))
@@ -111,6 +117,9 @@
 (assert_trap (invoke "i32.trunc_s_f64" (f64.const infinity)) "integer overflow")
 (assert_trap (invoke "i32.trunc_s_f64" (f64.const -infinity)) "integer overflow")
 (assert_trap (invoke "i32.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_s_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
 
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 0.0)) (i32.const 0))
 (assert_return (invoke "i32.trunc_u_f64" (f64.const -0.0)) (i32.const 0))
@@ -134,6 +143,9 @@
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const infinity)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const -infinity)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
 
 (assert_return (invoke "i64.trunc_s_f32" (f32.const 0.0)) (i64.const 0))
 (assert_return (invoke "i64.trunc_s_f32" (f32.const -0.0)) (i64.const 0))
@@ -156,6 +168,9 @@
 (assert_trap (invoke "i64.trunc_s_f32" (f32.const infinity)) "integer overflow")
 (assert_trap (invoke "i64.trunc_s_f32" (f32.const -infinity)) "integer overflow")
 (assert_trap (invoke "i64.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_s_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
 
 (assert_return (invoke "i64.trunc_u_f32" (f32.const 0.0)) (i64.const 0))
 (assert_return (invoke "i64.trunc_u_f32" (f32.const -0.0)) (i64.const 0))
@@ -173,6 +188,9 @@
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const infinity)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const -infinity)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_u_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
 
 (assert_return (invoke "i64.trunc_s_f64" (f64.const 0.0)) (i64.const 0))
 (assert_return (invoke "i64.trunc_s_f64" (f64.const -0.0)) (i64.const 0))
@@ -195,6 +213,9 @@
 (assert_trap (invoke "i64.trunc_s_f64" (f64.const infinity)) "integer overflow")
 (assert_trap (invoke "i64.trunc_s_f64" (f64.const -infinity)) "integer overflow")
 (assert_trap (invoke "i64.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_s_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
 
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 0.0)) (i64.const 0))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const -0.0)) (i64.const 0))
@@ -216,6 +237,9 @@
 (assert_trap (invoke "i64.trunc_u_f64" (f64.const infinity)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f64" (f64.const -infinity)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_u_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
 
 (assert_return (invoke "f32.convert_s_i32" (i32.const 1)) (f32.const 1.0))
 (assert_return (invoke "f32.convert_s_i32" (i32.const -1)) (f32.const -1.0))
@@ -320,7 +344,10 @@
 (assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37))
 (assert_return (invoke "f64.promote_f32" (f32.const infinity)) (f64.const infinity))
 (assert_return (invoke "f64.promote_f32" (f32.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "f64.promote_f32" (f32.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "f64.promote_f32" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "f64.promote_f32" (f32.const -nan:0x200000)))
 
 (assert_return (invoke "f32.demote_f64" (f64.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.demote_f64" (f64.const -0.0)) (f32.const -0.0))
@@ -364,7 +391,10 @@
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.cb98354d521ffp-127)) (f32.const 0x1.cb9834p-127))
 (assert_return (invoke "f32.demote_f64" (f64.const -0x1.6972b30cfb562p+1)) (f32.const -0x1.6972b4p+1))
 (assert_return (invoke "f32.demote_f64" (f64.const -0x1.bedbe4819d4c4p+112)) (f32.const -0x1.bedbe4p+112))
-(assert_return (invoke "f32.demote_f64" (f64.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.demote_f64" (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "f32.demote_f64" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f32.demote_f64" (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "f32.demote_f64" (f64.const -nan:0x4000000000000)))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1p-1022)) (f32.const 0.0))
 (assert_return (invoke "f32.demote_f64" (f64.const -0x1p-1022)) (f32.const -0.0))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.0p-150)) (f32.const 0.0))
diff --git a/test/core/f32.wast b/test/core/f32.wast
index 790cc0b3d5..672eca76ce 100644
--- a/test/core/f32.wast
+++ b/test/core/f32.wast
@@ -1,5 +1,6 @@
 ;; Test all the f32 operators on major boundary values and all special
-;; values (except comparison operators, which are tested in f32_cmp.wast).
+;; values (except comparison and bitwise operators, which are tested in
+;; f32_bitwise.wast and f32_cmp.wast).
 
 (module
   (func (export "add") (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
@@ -13,9 +14,6 @@
   (func (export "floor") (param $x f32) (result f32) (f32.floor (get_local $x)))
   (func (export "trunc") (param $x f32) (result f32) (f32.trunc (get_local $x)))
   (func (export "nearest") (param $x f32) (result f32) (f32.nearest (get_local $x)))
-  (func (export "abs") (param $x f32) (result f32) (f32.abs (get_local $x)))
-  (func (export "neg") (param $x f32) (result f32) (f32.neg (get_local $x)))
-  (func (export "copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (get_local $x) (get_local $y)))
 )
 
 (assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -51,9 +49,13 @@
 (assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const 0x0p+0) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x0p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x0p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x0p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x0p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
 (assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149))
 (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149))
@@ -87,9 +89,13 @@
 (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-149) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-149) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1p-149) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1p-149) (f32.const nan:0x200000)))
 (assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
 (assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126))
 (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126))
@@ -123,9 +129,13 @@
 (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-126) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-126) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1p-126) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1p-126) (f32.const nan:0x200000)))
 (assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
 (assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1))
 (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1))
@@ -159,9 +169,13 @@
 (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-1) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-1) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1p-1) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1p-1) (f32.const nan:0x200000)))
 (assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
 (assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0))
 (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0))
@@ -195,9 +209,13 @@
 (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2))
@@ -231,9 +249,13 @@
 (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127))
@@ -267,9 +289,13 @@
 (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return (invoke "add" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "add" (f32.const infinity) (f32.const -0x0p+0)) (f32.const infinity))
@@ -303,45 +329,93 @@
 (assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const -infinity)))
 (assert_return (invoke "add" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "add" (f32.const -infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -infinity) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const nan:0x200000)))
 (assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
@@ -375,9 +449,13 @@
 (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const infinity)) (f32.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x0p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x0p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x0p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x0p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
 (assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149))
 (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149))
@@ -411,9 +489,13 @@
 (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const infinity)) (f32.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-149) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-149) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1p-149) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1p-149) (f32.const nan:0x200000)))
 (assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
 (assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126))
 (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126))
@@ -447,9 +529,13 @@
 (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const infinity)) (f32.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-126) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-126) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1p-126) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1p-126) (f32.const nan:0x200000)))
 (assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
 (assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1))
 (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1))
@@ -483,9 +569,13 @@
 (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const infinity)) (f32.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-1) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-1) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1p-1) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1p-1) (f32.const nan:0x200000)))
 (assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
 (assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0))
 (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0))
@@ -519,9 +609,13 @@
 (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const infinity)) (f32.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2))
@@ -555,9 +649,13 @@
 (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127))
@@ -591,9 +689,13 @@
 (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "sub" (f32.const infinity) (f32.const -0x0p+0)) (f32.const infinity))
@@ -627,45 +729,93 @@
 (assert_return (invoke "sub" (f32.const infinity) (f32.const -infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -infinity) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const nan:0x200000)))
 (assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -699,9 +849,13 @@
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x0p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x0p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -735,9 +889,13 @@
 (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-149) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-149) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1p-149) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1p-149) (f32.const nan:0x200000)))
 (assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -771,9 +929,13 @@
 (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-126) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-126) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1p-126) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1p-126) (f32.const nan:0x200000)))
 (assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -807,9 +969,13 @@
 (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-1) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-1) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1p-1) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1p-1) (f32.const nan:0x200000)))
 (assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -843,9 +1009,13 @@
 (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -879,9 +1049,13 @@
 (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -915,9 +1089,13 @@
 (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const -0x0p+0)))
@@ -951,45 +1129,93 @@
 (assert_return (invoke "mul" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "mul" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x0p+0) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x0p+0) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x0p+0) (f32.const -0x0p+0)))
@@ -1023,9 +1249,13 @@
 (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x0p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x0p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x0p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x0p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const infinity))
 (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -infinity))
@@ -1059,9 +1289,13 @@
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-149) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-149) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-149) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-149) (f32.const nan:0x200000)))
 (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const infinity))
 (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -infinity))
@@ -1095,9 +1329,13 @@
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-126) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-126) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-126) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-126) (f32.const nan:0x200000)))
 (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const infinity))
 (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -infinity))
@@ -1131,9 +1369,13 @@
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-1) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-1) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-1) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-1) (f32.const nan:0x200000)))
 (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const infinity))
 (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -infinity))
@@ -1167,9 +1409,13 @@
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p+0) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const infinity))
 (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -infinity))
@@ -1203,9 +1449,13 @@
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const infinity))
 (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -infinity))
@@ -1239,9 +1489,13 @@
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return (invoke "div" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const infinity))
 (assert_return (invoke "div" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity))
 (assert_return (invoke "div" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -infinity))
@@ -1275,45 +1529,93 @@
 (assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const nan:0x200000)))
 (assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1347,9 +1649,11 @@
 (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x0p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x0p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const 0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x0p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x0p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
@@ -1385,9 +1689,11 @@
 (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x1p-149))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-149) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-149) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const 0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1p-149) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1p-149) (f32.const nan:0x200000)))
 (assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
@@ -1423,9 +1729,11 @@
 (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x1p-126))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-126) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-126) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const 0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1p-126) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1p-126) (f32.const nan:0x200000)))
 (assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
@@ -1461,9 +1769,11 @@
 (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x1p-1))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-1) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-1) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const 0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1p-1) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1p-1) (f32.const nan:0x200000)))
 (assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
@@ -1499,9 +1809,11 @@
 (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x1p+0))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const 0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
@@ -1537,9 +1849,11 @@
 (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
@@ -1575,9 +1889,11 @@
 (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return (invoke "min" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
@@ -1613,65 +1929,93 @@
 (assert_return (invoke "min" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "min" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "min" (f32.const -infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -infinity) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const infinity) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x0p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x0p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -0x1p-149)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1p-149)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-149)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1p-149)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -0x1p-126)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1p-126)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-126)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1p-126)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -0x1p-1)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1p-1)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-1)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1p-1)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -0x1p+0)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p+0)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -0x1.921fb6p+2)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1.921fb6p+2)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1.921fb6p+2)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -0x1.fffffep+127)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1.fffffep+127)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1.fffffep+127)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const infinity)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -infinity)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const infinity)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -nan)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const nan:0x200000)))
 (assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
@@ -1705,9 +2049,11 @@
 (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x0p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x0p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x0p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const 0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x0p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x0p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1743,9 +2089,11 @@
 (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const 0x1p-149))
 (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-149) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-149) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1p-149) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const 0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1p-149) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1p-149) (f32.const nan:0x200000)))
 (assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1781,9 +2129,11 @@
 (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const 0x1p-126))
 (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-126) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-126) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1p-126) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const 0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1p-126) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1p-126) (f32.const nan:0x200000)))
 (assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1819,9 +2169,11 @@
 (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const 0x1p-1))
 (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-1) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-1) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1p-1) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const 0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1p-1) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1p-1) (f32.const nan:0x200000)))
 (assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1857,9 +2209,11 @@
 (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const 0x1p+0))
 (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p+0) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1p+0) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const 0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1p+0) (f32.const nan:0x200000)))
 (assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1895,9 +2249,11 @@
 (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const 0x1.921fb6p+2))
 (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)))
 (assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1933,9 +2289,11 @@
 (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
 (assert_return (invoke "max" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1971,373 +2329,93 @@
 (assert_return (invoke "max" (f32.const infinity) (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "max" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "max" (f32.const -infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -infinity) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const infinity) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const infinity) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const infinity) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const infinity) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -0x1p-149)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-149)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x1p-149)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-149)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -0x1p-126)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-126)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x1p-126)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-126)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x1.fffffep+127)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -infinity)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -infinity)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const infinity)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const infinity)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -nan) (f32.const nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan) (f32.const -nan:0x200000)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const nan) (f32.const nan:0x200000)))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -nan)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const nan)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -nan)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const nan)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const infinity)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -nan)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const nan)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -nan)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const nan)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const infinity)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -nan)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const nan)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -nan)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const nan)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const infinity)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -nan)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const nan)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -nan)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const nan)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const infinity)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -nan)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const nan)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -nan)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const nan)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -nan)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const nan)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -nan)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const nan)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x0p+0)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x0p+0)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-149)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-149)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-126)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-126)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-1)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-1)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p+0)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p+0)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -infinity)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const infinity)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -infinity)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const infinity)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const nan)) (f32.const nan))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const nan:0x200000)))
 (assert_return (invoke "sqrt" (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "sqrt" (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1p-149)))
@@ -2355,7 +2433,9 @@
 (assert_return_canonical_nan (invoke "sqrt" (f32.const -infinity)))
 (assert_return (invoke "sqrt" (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "sqrt" (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sqrt" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sqrt" (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sqrt" (f32.const nan:0x200000)))
 (assert_return (invoke "floor" (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "floor" (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "floor" (f32.const -0x1p-149)) (f32.const -0x1p+0))
@@ -2373,7 +2453,9 @@
 (assert_return (invoke "floor" (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "floor" (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "floor" (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "floor" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "floor" (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "floor" (f32.const nan:0x200000)))
 (assert_return (invoke "ceil" (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "ceil" (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "ceil" (f32.const -0x1p-149)) (f32.const -0x0p+0))
@@ -2391,7 +2473,9 @@
 (assert_return (invoke "ceil" (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "ceil" (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "ceil" (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "ceil" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "ceil" (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "ceil" (f32.const nan:0x200000)))
 (assert_return (invoke "trunc" (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "trunc" (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "trunc" (f32.const -0x1p-149)) (f32.const -0x0p+0))
@@ -2409,7 +2493,9 @@
 (assert_return (invoke "trunc" (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "trunc" (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "trunc" (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "trunc" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "trunc" (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "trunc" (f32.const nan:0x200000)))
 (assert_return (invoke "nearest" (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "nearest" (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "nearest" (f32.const -0x1p-149)) (f32.const -0x0p+0))
@@ -2427,40 +2513,6 @@
 (assert_return (invoke "nearest" (f32.const -infinity)) (f32.const -infinity))
 (assert_return (invoke "nearest" (f32.const infinity)) (f32.const infinity))
 (assert_return_canonical_nan (invoke "nearest" (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "nearest" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "nearest" (f32.const nan)))
-(assert_return (invoke "abs" (f32.const -0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "abs" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "abs" (f32.const -0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "abs" (f32.const 0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "abs" (f32.const -0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "abs" (f32.const 0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "abs" (f32.const -0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "abs" (f32.const 0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "abs" (f32.const -0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "abs" (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "abs" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "abs" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "abs" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "abs" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "abs" (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "abs" (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "abs" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "abs" (f32.const nan)) (f32.const nan))
-(assert_return (invoke "neg" (f32.const -0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "neg" (f32.const 0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "neg" (f32.const -0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "neg" (f32.const 0x1p-149)) (f32.const -0x1p-149))
-(assert_return (invoke "neg" (f32.const -0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "neg" (f32.const 0x1p-126)) (f32.const -0x1p-126))
-(assert_return (invoke "neg" (f32.const -0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "neg" (f32.const 0x1p-1)) (f32.const -0x1p-1))
-(assert_return (invoke "neg" (f32.const -0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "neg" (f32.const 0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "neg" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "neg" (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "neg" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "neg" (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "neg" (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "neg" (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "neg" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "neg" (f32.const nan)) (f32.const -nan))
+(assert_return_arithmetic_nan (invoke "nearest" (f32.const nan:0x200000)))
diff --git a/test/core/f32_bitwise.wast b/test/core/f32_bitwise.wast
new file mode 100644
index 0000000000..473dba83f3
--- /dev/null
+++ b/test/core/f32_bitwise.wast
@@ -0,0 +1,369 @@
+;; Test all the f32 bitwise operators on major boundary values and all special
+;; values.
+
+(module
+  (func (export "abs") (param $x f32) (result f32) (f32.abs (get_local $x)))
+  (func (export "neg") (param $x f32) (result f32) (f32.neg (get_local $x)))
+  (func (export "copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (get_local $x) (get_local $y)))
+)
+
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -nan)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const nan)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -nan)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const nan)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const infinity)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -nan)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const nan)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -nan)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const nan)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const infinity)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -nan)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const nan)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -nan)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const nan)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const infinity)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -nan)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const nan)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -nan)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const nan)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const infinity)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -nan)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const nan)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -nan)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const nan)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -nan)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const -infinity) (f32.const nan)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const -nan)) (f32.const -infinity))
+(assert_return (invoke "copysign" (f32.const infinity) (f32.const nan)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x0p+0)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x0p+0)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-149)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-149)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-126)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-126)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-1)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-1)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p+0)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p+0)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -infinity)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const infinity)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -infinity)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const infinity)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "abs" (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "abs" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "abs" (f32.const -0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "abs" (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "abs" (f32.const -0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "abs" (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "abs" (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "abs" (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "abs" (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "abs" (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "abs" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "abs" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "abs" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "abs" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "abs" (f32.const -infinity)) (f32.const infinity))
+(assert_return (invoke "abs" (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "abs" (f32.const nan)) (f32.const nan))
+(assert_return (invoke "neg" (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "neg" (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "neg" (f32.const -0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "neg" (f32.const 0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "neg" (f32.const -0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "neg" (f32.const 0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "neg" (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "neg" (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "neg" (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "neg" (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "neg" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "neg" (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "neg" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "neg" (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "neg" (f32.const -infinity)) (f32.const infinity))
+(assert_return (invoke "neg" (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "neg" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "neg" (f32.const nan)) (f32.const -nan))
diff --git a/test/core/f32_cmp.wast b/test/core/f32_cmp.wast
index 9458069c30..7ad68bfd07 100644
--- a/test/core/f32_cmp.wast
+++ b/test/core/f32_cmp.wast
@@ -43,9 +43,13 @@
 (assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
@@ -79,9 +83,13 @@
 (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
@@ -115,9 +123,13 @@
 (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
@@ -151,9 +163,13 @@
 (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
@@ -187,9 +203,13 @@
 (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
@@ -223,9 +243,13 @@
 (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
@@ -259,9 +283,13 @@
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0))
@@ -295,45 +323,93 @@
 (assert_return (invoke "eq" (f32.const infinity) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const infinity) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "eq" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
@@ -367,9 +443,13 @@
 (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
@@ -403,9 +483,13 @@
 (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
@@ -439,9 +523,13 @@
 (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
@@ -475,9 +563,13 @@
 (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
@@ -511,9 +603,13 @@
 (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
@@ -547,9 +643,13 @@
 (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
@@ -583,9 +683,13 @@
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1))
@@ -619,45 +723,93 @@
 (assert_return (invoke "ne" (f32.const infinity) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const infinity) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ne" (f32.const -infinity) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -infinity) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const infinity) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const infinity) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
@@ -691,9 +843,13 @@
 (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
@@ -727,9 +883,13 @@
 (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
@@ -763,9 +923,13 @@
 (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
@@ -799,9 +963,13 @@
 (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
@@ -835,9 +1003,13 @@
 (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
@@ -871,9 +1043,13 @@
 (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
@@ -907,9 +1083,13 @@
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0))
@@ -943,45 +1123,93 @@
 (assert_return (invoke "lt" (f32.const infinity) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const infinity) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
@@ -1015,9 +1243,13 @@
 (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
@@ -1051,9 +1283,13 @@
 (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
@@ -1087,9 +1323,13 @@
 (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
@@ -1123,9 +1363,13 @@
 (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
@@ -1159,9 +1403,13 @@
 (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
@@ -1195,9 +1443,13 @@
 (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
@@ -1231,9 +1483,13 @@
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0))
@@ -1267,45 +1523,93 @@
 (assert_return (invoke "le" (f32.const infinity) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const infinity) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
@@ -1339,9 +1643,13 @@
 (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
@@ -1375,9 +1683,13 @@
 (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
@@ -1411,9 +1723,13 @@
 (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
@@ -1447,9 +1763,13 @@
 (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
@@ -1483,9 +1803,13 @@
 (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
@@ -1519,9 +1843,13 @@
 (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
@@ -1555,9 +1883,13 @@
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1))
@@ -1591,45 +1923,93 @@
 (assert_return (invoke "gt" (f32.const infinity) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const infinity) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
@@ -1663,9 +2043,13 @@
 (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
@@ -1699,9 +2083,13 @@
 (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
@@ -1735,9 +2123,13 @@
 (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
@@ -1771,9 +2163,13 @@
 (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
@@ -1807,9 +2203,13 @@
 (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
@@ -1843,9 +2243,13 @@
 (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
@@ -1879,9 +2283,13 @@
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1))
@@ -1915,42 +2323,90 @@
 (assert_return (invoke "ge" (f32.const infinity) (f32.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const infinity) (f32.const infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const infinity) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const infinity) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
diff --git a/test/core/f64.wast b/test/core/f64.wast
index 911f00f6e8..fddd6b3c1d 100644
--- a/test/core/f64.wast
+++ b/test/core/f64.wast
@@ -1,5 +1,6 @@
 ;; Test all the f64 operators on major boundary values and all special
-;; values (except comparison operators, which are tested in f64_cmp.wast).
+;; values (except comparison and bitwise operators, which are tested in
+;; f64_bitwise.wast and f64_cmp.wast).
 
 (module
   (func (export "add") (param $x f64) (param $y f64) (result f64) (f64.add (get_local $x) (get_local $y)))
@@ -13,9 +14,6 @@
   (func (export "floor") (param $x f64) (result f64) (f64.floor (get_local $x)))
   (func (export "trunc") (param $x f64) (result f64) (f64.trunc (get_local $x)))
   (func (export "nearest") (param $x f64) (result f64) (f64.nearest (get_local $x)))
-  (func (export "abs") (param $x f64) (result f64) (f64.abs (get_local $x)))
-  (func (export "neg") (param $x f64) (result f64) (f64.neg (get_local $x)))
-  (func (export "copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (get_local $x) (get_local $y)))
 )
 
 (assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -51,9 +49,13 @@
 (assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const 0x0p+0) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x0p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x0p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022))
@@ -87,9 +89,13 @@
 (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
 (assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022))
 (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022))
@@ -123,9 +129,13 @@
 (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
 (assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1))
 (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1))
@@ -159,9 +169,13 @@
 (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1p-1) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
 (assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0))
 (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0))
@@ -195,9 +209,13 @@
 (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
@@ -231,9 +249,13 @@
 (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
@@ -267,9 +289,13 @@
 (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "add" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "add" (f64.const infinity) (f64.const -0x0p+0)) (f64.const infinity))
@@ -303,45 +329,93 @@
 (assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const -infinity)))
 (assert_return (invoke "add" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "add" (f64.const -infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -infinity) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
@@ -375,9 +449,13 @@
 (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const infinity)) (f64.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x0p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x0p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022))
@@ -411,9 +489,13 @@
 (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
 (assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022))
 (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022))
@@ -447,9 +529,13 @@
 (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
 (assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1))
 (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1))
@@ -483,9 +569,13 @@
 (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const infinity)) (f64.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1p-1) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
 (assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0))
 (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0))
@@ -519,9 +609,13 @@
 (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const infinity)) (f64.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
@@ -555,9 +649,13 @@
 (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
@@ -591,9 +689,13 @@
 (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -infinity))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "sub" (f64.const infinity) (f64.const -0x0p+0)) (f64.const infinity))
@@ -627,45 +729,93 @@
 (assert_return (invoke "sub" (f64.const infinity) (f64.const -infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -infinity) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -699,9 +849,13 @@
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -735,9 +889,13 @@
 (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -771,9 +929,13 @@
 (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -807,9 +969,13 @@
 (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1p-1) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -843,9 +1009,13 @@
 (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -879,9 +1049,13 @@
 (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -915,9 +1089,13 @@
 (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const -0x0p+0)))
@@ -951,45 +1129,93 @@
 (assert_return (invoke "mul" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "mul" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0p+0) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0p+0) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x0p+0) (f64.const -0x0p+0)))
@@ -1023,9 +1249,13 @@
 (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x0p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const infinity))
 (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -infinity))
@@ -1059,9 +1289,13 @@
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const infinity))
 (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -infinity))
@@ -1095,9 +1329,13 @@
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p-1022) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const infinity))
 (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -infinity))
@@ -1131,9 +1369,13 @@
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p-1) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const infinity))
 (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -infinity))
@@ -1167,9 +1409,13 @@
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p+0) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const infinity))
 (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -infinity))
@@ -1203,9 +1449,13 @@
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const infinity))
 (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -infinity))
@@ -1239,9 +1489,13 @@
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "div" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const infinity))
 (assert_return (invoke "div" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity))
 (assert_return (invoke "div" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -infinity))
@@ -1275,45 +1529,93 @@
 (assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1347,9 +1649,11 @@
 (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x0p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x0p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
@@ -1385,9 +1689,11 @@
 (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
@@ -1423,9 +1729,11 @@
 (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
@@ -1461,9 +1769,11 @@
 (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x1p-1))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1p-1) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
@@ -1499,9 +1809,11 @@
 (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x1p+0))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
@@ -1537,9 +1849,11 @@
 (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
@@ -1575,9 +1889,11 @@
 (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "min" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
@@ -1613,65 +1929,93 @@
 (assert_return (invoke "min" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "min" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "min" (f64.const -infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -infinity) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const infinity) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x0p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x0p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -0x0.0000000000001p-1022)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -0x1p-1022)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1p-1022)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1p-1022)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -0x1p-1)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1p-1)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1p-1)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -0x1p+0)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const infinity)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -infinity)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const infinity)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -nan)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
@@ -1705,9 +2049,11 @@
 (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x0p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x0p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x0p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1743,9 +2089,11 @@
 (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const 0x0.0000000000001p-1022))
 (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1781,9 +2129,11 @@
 (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const 0x1p-1022))
 (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1p-1022) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1819,9 +2169,11 @@
 (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const 0x1p-1))
 (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1p-1) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1p-1) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1857,9 +2209,11 @@
 (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const 0x1p+0))
 (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1p+0) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1895,9 +2249,11 @@
 (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1933,9 +2289,11 @@
 (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "max" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1971,389 +2329,93 @@
 (assert_return (invoke "max" (f64.const infinity) (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "max" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "max" (f64.const -infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -infinity) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const infinity) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const infinity) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const infinity) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const infinity) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x0p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x0p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x0p+0)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x0p+0)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -0x0.0000000000001p-1022)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -0x1p-1022)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1p-1022)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x1p-1)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x1p-1)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -0x1p-1)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1p-1)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1p-1)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x1p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x1p+0)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -0x1p+0)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1p+0)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1p+0)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -infinity)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const infinity)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const infinity)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -infinity)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const infinity)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const infinity)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -nan)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const nan) (f64.const -nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const nan)))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -nan)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const nan)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -nan)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const nan)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const infinity)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -nan)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const nan)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -nan)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const nan)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const infinity)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -nan)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const nan)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -nan)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const nan)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -nan)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const nan)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -nan)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const nan)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0p+0)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0p+0)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1022)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p+0)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p+0)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -infinity)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const infinity)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -infinity)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const infinity)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const nan)) (f64.const nan))
+(assert_return_arithmetic_nan (invoke "max" (f64.const nan) (f64.const nan:0x4000000000000)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)))
 (assert_return (invoke "sqrt" (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "sqrt" (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "sqrt" (f64.const -0x0.0000000000001p-1022)))
@@ -2371,7 +2433,9 @@
 (assert_return_canonical_nan (invoke "sqrt" (f64.const -infinity)))
 (assert_return (invoke "sqrt" (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "sqrt" (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sqrt" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sqrt" (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sqrt" (f64.const nan:0x4000000000000)))
 (assert_return (invoke "floor" (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "floor" (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "floor" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
@@ -2389,7 +2453,9 @@
 (assert_return (invoke "floor" (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "floor" (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "floor" (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "floor" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "floor" (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "floor" (f64.const nan:0x4000000000000)))
 (assert_return (invoke "ceil" (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "ceil" (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "ceil" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
@@ -2407,7 +2473,9 @@
 (assert_return (invoke "ceil" (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "ceil" (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "ceil" (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "ceil" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "ceil" (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "ceil" (f64.const nan:0x4000000000000)))
 (assert_return (invoke "trunc" (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "trunc" (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "trunc" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
@@ -2425,7 +2493,9 @@
 (assert_return (invoke "trunc" (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "trunc" (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "trunc" (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "trunc" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "trunc" (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "trunc" (f64.const nan:0x4000000000000)))
 (assert_return (invoke "nearest" (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "nearest" (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "nearest" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
@@ -2443,40 +2513,6 @@
 (assert_return (invoke "nearest" (f64.const -infinity)) (f64.const -infinity))
 (assert_return (invoke "nearest" (f64.const infinity)) (f64.const infinity))
 (assert_return_canonical_nan (invoke "nearest" (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "nearest" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "nearest" (f64.const nan)))
-(assert_return (invoke "abs" (f64.const -0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "abs" (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "abs" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "abs" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "abs" (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "abs" (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "abs" (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "abs" (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "abs" (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "abs" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "abs" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "abs" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "abs" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "abs" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "abs" (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "abs" (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "abs" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "abs" (f64.const nan)) (f64.const nan))
-(assert_return (invoke "neg" (f64.const -0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "neg" (f64.const 0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "neg" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "neg" (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "neg" (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "neg" (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "neg" (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "neg" (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "neg" (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "neg" (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "neg" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "neg" (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "neg" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "neg" (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "neg" (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "neg" (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "neg" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "neg" (f64.const nan)) (f64.const -nan))
+(assert_return_arithmetic_nan (invoke "nearest" (f64.const nan:0x4000000000000)))
diff --git a/test/core/f64_bitwise.wast b/test/core/f64_bitwise.wast
new file mode 100644
index 0000000000..5b719a6e6e
--- /dev/null
+++ b/test/core/f64_bitwise.wast
@@ -0,0 +1,369 @@
+;; Test all the f64 bitwise operators on major boundary values and all special
+;; values.
+
+(module
+  (func (export "abs") (param $x f64) (result f64) (f64.abs (get_local $x)))
+  (func (export "neg") (param $x f64) (result f64) (f64.neg (get_local $x)))
+  (func (export "copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (get_local $x) (get_local $y)))
+)
+
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -nan)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const nan)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -nan)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const nan)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const infinity)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -nan)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const nan)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -nan)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const nan)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const infinity)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -nan)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const nan)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -nan)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const nan)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -nan)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const -infinity) (f64.const nan)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const -nan)) (f64.const -infinity))
+(assert_return (invoke "copysign" (f64.const infinity) (f64.const nan)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0p+0)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0p+0)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1022)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p+0)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p+0)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -infinity)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const infinity)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -infinity)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const infinity)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "abs" (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "abs" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "abs" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "abs" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "abs" (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "abs" (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "abs" (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "abs" (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "abs" (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "abs" (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "abs" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "abs" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "abs" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "abs" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "abs" (f64.const -infinity)) (f64.const infinity))
+(assert_return (invoke "abs" (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "abs" (f64.const nan)) (f64.const nan))
+(assert_return (invoke "neg" (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "neg" (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "neg" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "neg" (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "neg" (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "neg" (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "neg" (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "neg" (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "neg" (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "neg" (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "neg" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "neg" (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "neg" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "neg" (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "neg" (f64.const -infinity)) (f64.const infinity))
+(assert_return (invoke "neg" (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "neg" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "neg" (f64.const nan)) (f64.const -nan))
diff --git a/test/core/f64_cmp.wast b/test/core/f64_cmp.wast
index f4958b8f98..1c22dc4189 100644
--- a/test/core/f64_cmp.wast
+++ b/test/core/f64_cmp.wast
@@ -43,9 +43,13 @@
 (assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
@@ -79,9 +83,13 @@
 (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
@@ -115,9 +123,13 @@
 (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
@@ -151,9 +163,13 @@
 (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
@@ -187,9 +203,13 @@
 (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
@@ -223,9 +243,13 @@
 (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
@@ -259,9 +283,13 @@
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0))
@@ -295,45 +323,93 @@
 (assert_return (invoke "eq" (f64.const infinity) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const infinity) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "eq" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
@@ -367,9 +443,13 @@
 (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
@@ -403,9 +483,13 @@
 (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
@@ -439,9 +523,13 @@
 (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
@@ -475,9 +563,13 @@
 (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
@@ -511,9 +603,13 @@
 (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
@@ -547,9 +643,13 @@
 (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
@@ -583,9 +683,13 @@
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1))
@@ -619,45 +723,93 @@
 (assert_return (invoke "ne" (f64.const infinity) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const infinity) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ne" (f64.const -infinity) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -infinity) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const infinity) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const infinity) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
@@ -691,9 +843,13 @@
 (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
@@ -727,9 +883,13 @@
 (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
@@ -763,9 +923,13 @@
 (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
@@ -799,9 +963,13 @@
 (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
@@ -835,9 +1003,13 @@
 (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
@@ -871,9 +1043,13 @@
 (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
@@ -907,9 +1083,13 @@
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0))
@@ -943,45 +1123,93 @@
 (assert_return (invoke "lt" (f64.const infinity) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const infinity) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
@@ -1015,9 +1243,13 @@
 (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
@@ -1051,9 +1283,13 @@
 (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
@@ -1087,9 +1323,13 @@
 (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
@@ -1123,9 +1363,13 @@
 (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
@@ -1159,9 +1403,13 @@
 (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
@@ -1195,9 +1443,13 @@
 (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
@@ -1231,9 +1483,13 @@
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "le" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0))
@@ -1267,45 +1523,93 @@
 (assert_return (invoke "le" (f64.const infinity) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const infinity) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
@@ -1339,9 +1643,13 @@
 (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
@@ -1375,9 +1683,13 @@
 (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
@@ -1411,9 +1723,13 @@
 (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
@@ -1447,9 +1763,13 @@
 (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
@@ -1483,9 +1803,13 @@
 (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
@@ -1519,9 +1843,13 @@
 (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
@@ -1555,9 +1883,13 @@
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1))
@@ -1591,45 +1923,93 @@
 (assert_return (invoke "gt" (f64.const infinity) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const infinity) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
@@ -1663,9 +2043,13 @@
 (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
@@ -1699,9 +2083,13 @@
 (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
@@ -1735,9 +2123,13 @@
 (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
@@ -1771,9 +2163,13 @@
 (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
@@ -1807,9 +2203,13 @@
 (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
@@ -1843,9 +2243,13 @@
 (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
@@ -1879,9 +2283,13 @@
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1))
@@ -1915,42 +2323,90 @@
 (assert_return (invoke "ge" (f64.const infinity) (f64.const -infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const infinity) (f64.const infinity)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const infinity) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const infinity) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
diff --git a/test/core/float_exprs.wast b/test/core/float_exprs.wast
index 0c9a0862a4..9069c158c3 100644
--- a/test/core/float_exprs.wast
+++ b/test/core/float_exprs.wast
@@ -248,7 +248,7 @@
 (assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.0138bf530a53cp+1007)) (f64.const -0x1.56f6546eb86fbp+1005))
 (assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.052b87f9d794dp+415)) (f64.const 0x1.5c3a0aa274c67p+413))
 
-;; Test that (x*z)+(y*z) is not folded to (x+y)*z
+;; Test that (x*z)+(y*z) is not folded to (x+y)*z.
 
 (module
   (func (export "f32.no_factor") (param $x f32) (param $y f32) (param $z f32) (result f32)
@@ -268,7 +268,7 @@
 (assert_return (invoke "f64.no_factor" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f184p-512))
 (assert_return (invoke "f64.no_factor" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af53p-90))
 
-;; Test that (x+y)*z is not folded to (x*z)+(y*z)
+;; Test that (x+y)*z is not folded to (x*z)+(y*z).
 
 (module
   (func (export "f32.no_distribute") (param $x f32) (param $y f32) (param $z f32) (result f32)
@@ -288,7 +288,7 @@
 (assert_return (invoke "f64.no_distribute" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f183p-512))
 (assert_return (invoke "f64.no_distribute" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af52p-90))
 
-;; Test that x*(y/z) is not folded to (x*y)/z
+;; Test that x*(y/z) is not folded to (x*y)/z.
 
 (module
   (func (export "f32.no_regroup_div_mul") (param $x f32) (param $y f32) (param $z f32) (result f32)
@@ -308,7 +308,7 @@
 (assert_return (invoke "f64.no_regroup_div_mul" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -0x1.926fa3cacc651p+255))
 (assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x1.38d55f56406dp-639))
 
-;; Test that (x*y)/z is not folded to x*(y/z)
+;; Test that (x*y)/z is not folded to x*(y/z).
 
 (module
   (func (export "f32.no_regroup_mul_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
@@ -489,7 +489,7 @@
 (assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.ba4c5p+13)) (f32.const 0x1.136f16p-7))
 (assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.4a5be2p+104)) (f32.const 0x1.c2b5bp-53))
 
-;; Test that converting i32/i64 to f32/f64 and back isn't folded away
+;; Test that converting i32/i64 to f32/f64 and back isn't folded away.
 
 (module
   (func (export "i32.no_fold_f32_s") (param i32) (result i32)
@@ -959,7 +959,7 @@
 (assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_ge_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
 
-;; Test that x<0?-x:x, etc. using select aren't folded to abs
+;; Test that x<0?-x:x, etc. using select aren't folded to abs.
 
 (module
   (func (export "f32.no_fold_lt_select_to_abs") (param $x f32) (result f32) (select (f32.neg (get_local $x)) (get_local $x) (f32.lt (get_local $x) (f32.const 0.0))))
@@ -1006,7 +1006,7 @@
 (assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
 
-;; Test that x<0?-x:x, etc. using if aren't folded to abs
+;; Test that x<0?-x:x, etc. using if aren't folded to abs.
 
 (module
   (func (export "f32.no_fold_lt_if_to_abs") (param $x f32) (result f32) (if f32 (f32.lt (get_local $x) (f32.const 0.0)) (f32.neg (get_local $x)) (get_local $x)))
@@ -1057,20 +1057,16 @@
 ;; https://support.microsoft.com/en-us/kb/78113
 
 (module
-  (func (export "incorrect_correction") (result f32)
+  (func (export "f32.incorrect_correction") (result f32)
     (f32.sub (f32.sub (f32.add (f32.const 1.333) (f32.const 1.225)) (f32.const 1.333)) (f32.const 1.225))
   )
-)
-
-(assert_return (invoke "incorrect_correction") (f32.const 0x1p-23))
-
-(module
-  (func (export "incorrect_correction") (result f64)
+  (func (export "f64.incorrect_correction") (result f64)
     (f64.sub (f64.sub (f64.add (f64.const 1.333) (f64.const 1.225)) (f64.const 1.333)) (f64.const 1.225))
   )
 )
 
-(assert_return (invoke "incorrect_correction") (f64.const -0x1p-52))
+(assert_return (invoke "f32.incorrect_correction") (f32.const 0x1p-23))
+(assert_return (invoke "f64.incorrect_correction") (f64.const -0x1p-52))
 
 ;; Test for a historical calculator bug.
 ;; http://www.hpmuseum.org/cgi-sys/cgiwrap/hpmuseum/articles.cgi?read=735
diff --git a/test/core/float_misc.wast b/test/core/float_misc.wast
index 3ced1cc49a..4ad9bd6687 100644
--- a/test/core/float_misc.wast
+++ b/test/core/float_misc.wast
@@ -10,9 +10,9 @@
 ;; value-changing optimizations, and (d) that the WebAssembly implementation
 ;; doesn't exhibit any known implementation bugs.
 ;;
-;; This file supplements f32.wast, f64.wast, f32_cmp.wast, and f64_cmp.wast with
-;; additional single-instruction tests covering additional miscellaneous
-;; interesting cases.
+;; 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)))
@@ -57,10 +57,6 @@
 (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))
 
-;; Test that what some systems call signaling NaN behaves as a quiet NaN.
-(assert_return_arithmetic_nan (invoke "f32.add" (f32.const nan:0x200000) (f32.const 1.0)))
-(assert_return_arithmetic_nan (invoke "f64.add" (f64.const nan:0x4000000000000) (f64.const 1.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))
@@ -170,6 +166,12 @@
 (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 infinity))
+(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 infinity))
+
 ;; 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))
@@ -606,11 +608,11 @@
 (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 that ceil isn't implemented as adding 0.5 and rounding to nearest.
+;; 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 0x1p-126)) (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 0x1p-1022)) (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))
@@ -618,11 +620,11 @@
 (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 floor isn't implemented as subtracting 0.5 and rounding to nearest.
+;; 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 -0x1p-126)) (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 -0x1p-1022)) (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))
diff --git a/test/core/i32.wast b/test/core/i32.wast
index ee3a38bfa0..bd8722e614 100644
--- a/test/core/i32.wast
+++ b/test/core/i32.wast
@@ -64,6 +64,7 @@
 (assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow")
 (assert_return (invoke "div_s" (i32.const 1) (i32.const 1)) (i32.const 1))
 (assert_return (invoke "div_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "div_s" (i32.const 0) (i32.const -1)) (i32.const 0))
 (assert_return (invoke "div_s" (i32.const -1) (i32.const -1)) (i32.const 1))
 (assert_return (invoke "div_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0xc0000000))
 (assert_return (invoke "div_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0xffdf3b65))
@@ -100,6 +101,7 @@
 (assert_return (invoke "rem_s" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0))
 (assert_return (invoke "rem_s" (i32.const 1) (i32.const 1)) (i32.const 0))
 (assert_return (invoke "rem_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0) (i32.const -1)) (i32.const 0))
 (assert_return (invoke "rem_s" (i32.const -1) (i32.const -1)) (i32.const 0))
 (assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
 (assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
@@ -266,6 +268,7 @@
 (assert_return (invoke "eqz" (i32.const 1)) (i32.const 0))
 (assert_return (invoke "eqz" (i32.const 0x80000000)) (i32.const 0))
 (assert_return (invoke "eqz" (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "eqz" (i32.const 0xffffffff)) (i32.const 0))
 
 (assert_return (invoke "eq" (i32.const 0) (i32.const 0)) (i32.const 1))
 (assert_return (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1))
diff --git a/test/core/i64.wast b/test/core/i64.wast
index 40adc07522..6bb8a31e9f 100644
--- a/test/core/i64.wast
+++ b/test/core/i64.wast
@@ -64,6 +64,7 @@
 (assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
 (assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1))
 (assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "div_s" (i64.const 0) (i64.const -1)) (i64.const 0))
 (assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1))
 (assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000))
 (assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09))
@@ -100,6 +101,7 @@
 (assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0))
 (assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0))
 (assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0) (i64.const -1)) (i64.const 0))
 (assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0))
 (assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
 (assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
@@ -266,6 +268,7 @@
 (assert_return (invoke "eqz" (i64.const 1)) (i32.const 0))
 (assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0))
 (assert_return (invoke "eqz" (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0xffffffffffffffff)) (i32.const 0))
 
 (assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1))
 (assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1))
diff --git a/test/core/int_exprs.wast b/test/core/int_exprs.wast
index d050debcfd..99396a8b03 100644
--- a/test/core/int_exprs.wast
+++ b/test/core/int_exprs.wast
@@ -1,7 +1,7 @@
 ;; Test interesting integer "expressions". These tests contain code
 ;; patterns which tempt common value-changing optimizations.
 
-;; Test that x+1<y+1 is not folded to x<y
+;; Test that x+1<y+1 is not folded to x<y.
 
 (module
   (func (export "i32.no_fold_cmp_s_offset") (param $x i32) (param $y i32) (result i32)
@@ -20,7 +20,7 @@
 (assert_return (invoke "i64.no_fold_cmp_s_offset" (i64.const 0x7fffffffffffffff) (i64.const 0)) (i32.const 1))
 (assert_return (invoke "i64.no_fold_cmp_u_offset" (i64.const 0xffffffffffffffff) (i64.const 0)) (i32.const 1))
 
-;; Test that wrap(extend_s(x)) is not folded to x
+;; Test that wrap(extend_s(x)) is not folded to x.
 
 (module
   (func (export "i64.no_fold_wrap_extend_s") (param $x i64) (result i64)
@@ -30,7 +30,7 @@
 (assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
 (assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x00a0b0c0d0e0f0a0)) (i64.const 0xffffffffd0e0f0a0))
 
-;; Test that wrap(extend_u(x)) is not folded to x
+;; Test that wrap(extend_u(x)) is not folded to x.
 
 (module
   (func (export "i64.no_fold_wrap_extend_u") (param $x i64) (result i64)
@@ -39,7 +39,7 @@
 
 (assert_return (invoke "i64.no_fold_wrap_extend_u" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
 
-;; Test that x<<n>>n is not folded to x
+;; Test that x<<n>>n is not folded to x.
 
 (module
   (func (export "i32.no_fold_shl_shr_s") (param $x i32) (result i32)
@@ -58,7 +58,7 @@
 (assert_return (invoke "i64.no_fold_shl_shr_s" (i64.const 0x8000000000000000)) (i64.const 0))
 (assert_return (invoke "i64.no_fold_shl_shr_u" (i64.const 0x8000000000000000)) (i64.const 0))
 
-;; Test that x>>n<<n is not folded to x
+;; Test that x>>n<<n is not folded to x.
 
 (module
   (func (export "i32.no_fold_shr_s_shl") (param $x i32) (result i32)
@@ -77,7 +77,7 @@
 (assert_return (invoke "i64.no_fold_shr_s_shl" (i64.const 1)) (i64.const 0))
 (assert_return (invoke "i64.no_fold_shr_u_shl" (i64.const 1)) (i64.const 0))
 
-;; Test that x/n*n is not folded to x
+;; Test that x/n*n is not folded to x.
 
 (module
   (func (export "i32.no_fold_div_s_mul") (param $x i32) (result i32)
@@ -96,7 +96,7 @@
 (assert_return (invoke "i64.no_fold_div_s_mul" (i64.const 1)) (i64.const 0))
 (assert_return (invoke "i64.no_fold_div_u_mul" (i64.const 1)) (i64.const 0))
 
-;; Test that x/x is not folded to 1
+;; Test that x/x is not folded to 1.
 
 (module
   (func (export "i32.no_fold_div_s_self") (param $x i32) (result i32)
@@ -115,7 +115,7 @@
 (assert_trap (invoke "i64.no_fold_div_s_self" (i64.const 0)) "integer divide by zero")
 (assert_trap (invoke "i64.no_fold_div_u_self" (i64.const 0)) "integer divide by zero")
 
-;; Test that x%x is not folded to 0
+;; Test that x%x is not folded to 0.
 
 (module
   (func (export "i32.no_fold_rem_s_self") (param $x i32) (result i32)
@@ -134,7 +134,7 @@
 (assert_trap (invoke "i64.no_fold_rem_s_self" (i64.const 0)) "integer divide by zero")
 (assert_trap (invoke "i64.no_fold_rem_u_self" (i64.const 0)) "integer divide by zero")
 
-;; Test that x*n/n is not folded to x
+;; Test that x*n/n is not folded to x.
 
 (module
   (func (export "i32.no_fold_mul_div_s") (param $x i32) (result i32)
@@ -153,7 +153,7 @@
 (assert_return (invoke "i64.no_fold_mul_div_s" (i64.const 0x8000000000000000)) (i64.const 0))
 (assert_return (invoke "i64.no_fold_mul_div_u" (i64.const 0x8000000000000000)) (i64.const 0))
 
-;; Test that x/n where n is a known power of 2 is not folded to shr_s
+;; Test that x/n where n is a known power of 2 is not folded to shr_s.
 
 (module
   (func (export "i32.no_fold_div_s_2") (param $x i32) (result i32)
@@ -166,7 +166,7 @@
 (assert_return (invoke "i32.no_fold_div_s_2" (i32.const -11)) (i32.const -5))
 (assert_return (invoke "i64.no_fold_div_s_2" (i64.const -11)) (i64.const -5))
 
-;; Test that x%n where n is a known power of 2 is not folded to and
+;; Test that x%n where n is a known power of 2 is not folded to and.
 
 (module
   (func (export "i32.no_fold_rem_s_2") (param $x i32) (result i32)
@@ -179,26 +179,26 @@
 (assert_return (invoke "i32.no_fold_rem_s_2" (i32.const -11)) (i32.const -1))
 (assert_return (invoke "i64.no_fold_rem_s_2" (i64.const -11)) (i64.const -1))
 
-;; Test that x/0 works
+;; Test that x/0 works.
 
 (module
-  (func (export "i32.div_s_3") (param $x i32) (result i32)
+  (func (export "i32.div_s_0") (param $x i32) (result i32)
     (i32.div_s (get_local $x) (i32.const 0)))
-  (func (export "i32.div_u_3") (param $x i32) (result i32)
+  (func (export "i32.div_u_0") (param $x i32) (result i32)
     (i32.div_u (get_local $x) (i32.const 0)))
 
-  (func (export "i64.div_s_3") (param $x i64) (result i64)
+  (func (export "i64.div_s_0") (param $x i64) (result i64)
     (i64.div_s (get_local $x) (i64.const 0)))
-  (func (export "i64.div_u_3") (param $x i64) (result i64)
+  (func (export "i64.div_u_0") (param $x i64) (result i64)
     (i64.div_u (get_local $x) (i64.const 0)))
 )
 
-(assert_trap (invoke "i32.div_s_3" (i32.const 71)) "integer divide by zero")
-(assert_trap (invoke "i32.div_u_3" (i32.const 71)) "integer divide by zero")
-(assert_trap (invoke "i64.div_s_3" (i64.const 71)) "integer divide by zero")
-(assert_trap (invoke "i64.div_u_3" (i64.const 71)) "integer divide by zero")
+(assert_trap (invoke "i32.div_s_0" (i32.const 71)) "integer divide by zero")
+(assert_trap (invoke "i32.div_u_0" (i32.const 71)) "integer divide by zero")
+(assert_trap (invoke "i64.div_s_0" (i64.const 71)) "integer divide by zero")
+(assert_trap (invoke "i64.div_u_0" (i64.const 71)) "integer divide by zero")
 
-;; Test that x/3 works
+;; Test that x/3 works.
 
 (module
   (func (export "i32.div_s_3") (param $x i32) (result i32)
@@ -221,7 +221,7 @@
 (assert_return (invoke "i64.div_u_3" (i64.const 71)) (i64.const 23))
 (assert_return (invoke "i64.div_u_3" (i64.const 0xc000000000000000)) (i64.const 0x4000000000000000))
 
-;; Test that x/5 works
+;; Test that x/5 works.
 
 (module
   (func (export "i32.div_s_5") (param $x i32) (result i32)
@@ -244,7 +244,7 @@
 (assert_return (invoke "i64.div_u_5" (i64.const 71)) (i64.const 14))
 (assert_return (invoke "i64.div_u_5" (i64.const 0xa000000000000000)) (i64.const 0x2000000000000000))
 
-;; Test that x/7 works
+;; Test that x/7 works.
 
 (module
   (func (export "i32.div_s_7") (param $x i32) (result i32)
@@ -267,7 +267,7 @@
 (assert_return (invoke "i64.div_u_7" (i64.const 71)) (i64.const 10))
 (assert_return (invoke "i64.div_u_7" (i64.const 0xe000000000000000)) (i64.const 0x2000000000000000))
 
-;; Test that x%3 works
+;; Test that x%3 works.
 
 (module
   (func (export "i32.rem_s_3") (param $x i32) (result i32)
@@ -290,7 +290,7 @@
 (assert_return (invoke "i64.rem_u_3" (i64.const 71)) (i64.const 2))
 (assert_return (invoke "i64.rem_u_3" (i64.const 0xc000000000000000)) (i64.const 0))
 
-;; Test that x%5 works
+;; Test that x%5 works.
 
 (module
   (func (export "i32.rem_s_5") (param $x i32) (result i32)
@@ -313,7 +313,7 @@
 (assert_return (invoke "i64.rem_u_5" (i64.const 71)) (i64.const 1))
 (assert_return (invoke "i64.rem_u_5" (i64.const 0xa000000000000000)) (i64.const 0))
 
-;; Test that x%7 works
+;; Test that x%7 works.
 
 (module
   (func (export "i32.rem_s_7") (param $x i32) (result i32)
@@ -335,3 +335,16 @@
 (assert_return (invoke "i64.rem_s_7" (i64.const 0x7000000000000000)) (i64.const 0))
 (assert_return (invoke "i64.rem_u_7" (i64.const 71)) (i64.const 1))
 (assert_return (invoke "i64.rem_u_7" (i64.const 0xe000000000000000)) (i64.const 0))
+
+;; Test that x/-1 is not folded to -x.
+
+(module
+  (func (export "i32.no_fold_div_neg1") (param $x i32) (result i32)
+    (i32.div_s (get_local $x) (i32.const -1)))
+
+  (func (export "i64.no_fold_div_neg1") (param $x i64) (result i64)
+    (i64.div_s (get_local $x) (i64.const -1)))
+)
+
+(assert_trap (invoke "i32.no_fold_div_neg1" (i32.const 0x80000000)) "integer overflow")
+(assert_trap (invoke "i64.no_fold_div_neg1" (i64.const 0x8000000000000000)) "integer overflow")
diff --git a/test/core/memory.wast b/test/core/memory.wast
index c477ea4338..4539970c6a 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -350,6 +350,15 @@
 (assert_return (invoke "i32_load16_s" (i32.const 20000)) (i32.const 20000))
 (assert_return (invoke "i32_load16_u" (i32.const 40000)) (i32.const 40000))
 
+(assert_return (invoke "i32_load8_s" (i32.const 0xfedc6543)) (i32.const 0x43))
+(assert_return (invoke "i32_load8_s" (i32.const 0x3456cdef)) (i32.const 0xffffffef))
+(assert_return (invoke "i32_load8_u" (i32.const 0xfedc6543)) (i32.const 0x43))
+(assert_return (invoke "i32_load8_u" (i32.const 0x3456cdef)) (i32.const 0xef))
+(assert_return (invoke "i32_load16_s" (i32.const 0xfedc6543)) (i32.const 0x6543))
+(assert_return (invoke "i32_load16_s" (i32.const 0x3456cdef)) (i32.const 0xffffcdef))
+(assert_return (invoke "i32_load16_u" (i32.const 0xfedc6543)) (i32.const 0x6543))
+(assert_return (invoke "i32_load16_u" (i32.const 0x3456cdef)) (i32.const 0xcdef))
+
 (assert_return (invoke "i64_load8_s" (i64.const -1)) (i64.const -1))
 (assert_return (invoke "i64_load8_u" (i64.const -1)) (i64.const 255))
 (assert_return (invoke "i64_load16_s" (i64.const -1)) (i64.const -1))
@@ -363,3 +372,16 @@
 (assert_return (invoke "i64_load16_u" (i64.const 40000)) (i64.const 40000))
 (assert_return (invoke "i64_load32_s" (i64.const 20000)) (i64.const 20000))
 (assert_return (invoke "i64_load32_u" (i64.const 40000)) (i64.const 40000))
+
+(assert_return (invoke "i64_load8_s" (i64.const 0xfedcba9856346543)) (i64.const 0x43))
+(assert_return (invoke "i64_load8_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffffffffffef))
+(assert_return (invoke "i64_load8_u" (i64.const 0xfedcba9856346543)) (i64.const 0x43))
+(assert_return (invoke "i64_load8_u" (i64.const 0x3456436598bacdef)) (i64.const 0xef))
+(assert_return (invoke "i64_load16_s" (i64.const 0xfedcba9856346543)) (i64.const 0x6543))
+(assert_return (invoke "i64_load16_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffffffffcdef))
+(assert_return (invoke "i64_load16_u" (i64.const 0xfedcba9856346543)) (i64.const 0x6543))
+(assert_return (invoke "i64_load16_u" (i64.const 0x3456436598bacdef)) (i64.const 0xcdef))
+(assert_return (invoke "i64_load32_s" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
+(assert_return (invoke "i64_load32_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffff98bacdef))
+(assert_return (invoke "i64_load32_u" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
+(assert_return (invoke "i64_load32_u" (i64.const 0x3456436598bacdef)) (i64.const 0x98bacdef))