From e4aa802e2281bba570b36b7c6b4d871751c9ab2c Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 19 Nov 2019 20:33:08 +0100
Subject: [PATCH] [interpreter] Unify assert_result* assertions

---
 interpreter/README.md        |   12 +-
 interpreter/exec/float.ml    |    2 +
 interpreter/script/js.ml     |  120 +--
 interpreter/script/run.ml    |   91 +-
 interpreter/script/script.ml |   13 +-
 interpreter/text/arrange.ml  |   21 +-
 interpreter/text/lexer.mll   |    4 +-
 interpreter/text/parser.mly  |   25 +-
 test/core/conversions.wast   |   16 +-
 test/core/f32.wast           | 1822 +++++++++++++++++-----------------
 test/core/f64.wast           | 1822 +++++++++++++++++-----------------
 test/core/float_exprs.wast   |  126 +--
 test/core/float_misc.wast    |    2 +-
 13 files changed, 2071 insertions(+), 2005 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 67c58da8e0..a69c7849c2 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -324,9 +324,7 @@ action:
   ( get <name>? <string> )                   ;; get global export
 
 assertion:
-  ( assert_return <action> <expr>* )         ;; assert action has expected results
-  ( assert_return_canonical_nan <action> )   ;; assert action results in NaN in a canonical form
-  ( assert_return_arithmetic_nan <action> )  ;; assert action results in NaN with 1 in MSB of fraction field
+  ( assert_return <action> <result>* )       ;; assert action has expected results
   ( assert_trap <action> <failure> )         ;; assert action traps with given failure string
   ( assert_exhaustion <action> <failure> )   ;; assert action exhausts system resources
   ( assert_malformed <module> <failure> )    ;; assert module cannot be decoded with given failure string
@@ -334,6 +332,14 @@ assertion:
   ( assert_unlinkable <module> <failure> )   ;; assert module fails to link
   ( assert_trap <module> <failure> )         ;; assert module traps on instantiation
 
+result:
+  ( <val_type>.const <numpat> )
+
+numpat:
+  <value>                                    ;; literal result
+  nan:canonical                              ;; NaN in canonical form
+  nan:arithmetic                             ;; NaN with 1 in MSB of payload
+
 meta:
   ( script <name>? <script> )                ;; name a subscript
   ( input <name>? <string> )                 ;; read script or module from file
diff --git a/interpreter/exec/float.ml b/interpreter/exec/float.ml
index ee84b467c3..b47fd308ae 100644
--- a/interpreter/exec/float.ml
+++ b/interpreter/exec/float.ml
@@ -30,6 +30,8 @@ sig
   type bits
   val pos_nan : t
   val neg_nan : t
+  val is_inf : t -> bool
+  val is_nan : t -> bool
   val of_float : float -> t
   val to_float : t -> float
   val of_string : string -> t
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 824e8bb88a..f4ec97c310 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -122,27 +122,21 @@ function assert_exhaustion(action) {
 
 function assert_return(action, expected) {
   let actual = action();
-  if (!Object.is(actual, expected)) {
-    throw new Error("Wasm return value " + expected + " expected, got " + actual);
-  };
-}
-
-function assert_return_canonical_nan(action) {
-  let actual = action();
-  // Note that JS can't reliably distinguish different NaN values,
-  // so there's no good way to test that it's a canonical NaN.
-  if (!Number.isNaN(actual)) {
-    throw new Error("Wasm return value NaN expected, got " + actual);
-  };
-}
-
-function assert_return_arithmetic_nan(action) {
-  // Note that JS can't reliably distinguish different NaN values,
-  // so there's no good way to test for specific bitpatterns here.
-  let actual = action();
-  if (!Number.isNaN(actual)) {
-    throw new Error("Wasm return value NaN expected, got " + actual);
-  };
+  switch (expected) {
+    case "nan:canonical":
+    case "nan:arithmetic":
+    case "nan:any":
+      // Note that JS can't reliably distinguish different NaN values,
+      // so there's no good way to test that it's a canonical NaN.
+      if (!Number.isNaN(actual)) {
+        throw new Error("Wasm return value NaN expected, got " + actual);
+      };
+      return;
+    default:
+      if (!Object.is(actual, expected)) {
+        throw new Error("Wasm return value " + expected + " expected, got " + actual);
+      };
+  }
 }
 |}
 
@@ -220,36 +214,38 @@ let get t at =
 let run ts at =
   [], []
 
-let assert_return lits ts at =
-  let test lit =
-    let t', reinterpret = reinterpret_of (Values.type_of lit.it) in
-    [ reinterpret @@ at;
-      Const lit @@ at;
-      reinterpret @@ at;
-      Compare (eq_of t') @@ at;
-      Test (Values.I32 I32Op.Eqz) @@ at;
-      BrIf (0l @@ at) @@ at ]
-  in [], List.flatten (List.rev_map test lits)
-
-let assert_return_nan_bitpattern nan_bitmask_of ts at =
-  let test t =
-    let t', reinterpret = reinterpret_of t in
-    [ reinterpret @@ at;
-      Const (nan_bitmask_of t' @@ at) @@ at;
-      Binary (and_of t') @@ at;
-      Const (canonical_nan_of t' @@ at) @@ at;
-      Compare (eq_of t') @@ at;
-      Test (Values.I32 I32Op.Eqz) @@ at;
-      BrIf (0l @@ at) @@ at ]
-  in [], List.flatten (List.rev_map test ts)
-
-let assert_return_canonical_nan =
-  (* The result may only differ from the canonical NaN in its sign bit *)
-  assert_return_nan_bitpattern abs_mask_of
-
-let assert_return_arithmetic_nan =
-  (* The result can be any NaN that's one everywhere the canonical NaN is one *)
-  assert_return_nan_bitpattern canonical_nan_of
+let assert_return ress ts at =
+  let test res =
+    match res.it with
+    | LitResult lit ->
+      let t', reinterpret = reinterpret_of (Values.type_of lit.it) in
+      [ reinterpret @@ at;
+        Const lit @@ at;
+        reinterpret @@ at;
+        Compare (eq_of t') @@ at;
+        Test (Values.I32 I32Op.Eqz) @@ at;
+        BrIf (0l @@ at) @@ at ]
+    | NanResult nanop ->
+      let nan =
+        match nanop.it with
+        | Values.I32 _ | Values.I64 _ -> assert false
+        | Values.F32 n | Values.F64 n -> n
+      in
+      let nan_bitmask_of =
+        match nan with
+        | CanonicalNan -> abs_mask_of (* must only differ from the canonical NaN in its sign bit *)
+        | ArithmeticNan -> canonical_nan_of (* can be any NaN that's one everywhere the canonical NaN is one *)
+      in
+      let t = Values.type_of nanop.it in
+      let t', reinterpret = reinterpret_of t in
+      [ reinterpret @@ at;
+        Const (nan_bitmask_of t' @@ at) @@ at;
+        Binary (and_of t') @@ at;
+        Const (canonical_nan_of t' @@ at) @@ at;
+        Compare (eq_of t') @@ at;
+        Test (Values.I32 I32Op.Eqz) @@ at;
+        BrIf (0l @@ at) @@ at ]
+  in [], List.flatten (List.rev_map test ress)
 
 let wrap module_name item_name wrap_action wrap_assertion at =
   let itypes, idesc, action = wrap_action at in
@@ -321,6 +317,18 @@ let of_literal lit =
   | Values.F32 z -> of_float (F32.to_float z)
   | Values.F64 z -> of_float (F64.to_float z)
 
+let of_nan = function
+  | CanonicalNan -> "nan:canonical"
+  | ArithmeticNan -> "nan:arithmetic"
+
+let of_result res =
+  match res.it with
+  | LitResult lit -> of_literal lit
+  | NanResult nanop ->
+    match nanop.it with
+    | Values.I32 _ | Values.I64 _ -> assert false
+    | Values.F32 n | Values.F64 n -> of_nan n
+
 let rec of_definition def =
   match def.it with
   | Textual m -> of_bytes (Encode.encode m)
@@ -377,13 +385,9 @@ let of_assertion mods ass =
     "assert_unlinkable(" ^ of_definition def ^ ");"
   | AssertUninstantiable (def, _) ->
     "assert_uninstantiable(" ^ of_definition def ^ ");"
-  | AssertReturn (act, lits) ->
-    of_assertion' mods act "assert_return" (List.map of_literal lits)
-      (Some (assert_return lits))
-  | AssertReturnCanonicalNaN act ->
-    of_assertion' mods act "assert_return_canonical_nan" [] (Some assert_return_canonical_nan)
-  | AssertReturnArithmeticNaN act ->
-    of_assertion' mods act "assert_return_arithmetic_nan" [] (Some assert_return_arithmetic_nan)
+  | AssertReturn (act, ress) ->
+    of_assertion' mods act "assert_return" (List.map of_result ress)
+      (Some (assert_return ress))
   | AssertTrap (act, _) ->
     of_assertion' mods act "assert_trap" [] None
   | AssertExhaustion (act, _) ->
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index d1ec2866b6..9520628553 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -238,12 +238,39 @@ let print_module x_opt m =
   List.iter (print_export m) m.it.Ast.exports;
   flush_all ()
 
-let print_result vs =
+let print_values vs =
   let ts = List.map Values.type_of vs in
   Printf.printf "%s : %s\n"
     (Values.string_of_values vs) (Types.string_of_value_types ts);
   flush_all ()
 
+let string_of_nan = function
+  | CanonicalNan -> "nan:canonical"
+  | ArithmeticNan -> "nan:arithmetic"
+
+let type_of_result r =
+  match r with
+  | LitResult v -> Values.type_of v.it
+  | NanResult n -> Values.type_of n.it
+
+let string_of_result r =
+  match r with
+  | LitResult v -> Values.string_of_value v.it
+  | NanResult nanop ->
+    match nanop.it with
+    | Values.I32 _ | Values.I64 _ -> assert false
+    | Values.F32 n | Values.F64 n -> string_of_nan n
+
+let string_of_results = function
+  | [r] -> string_of_result r
+  | rs -> "[" ^ String.concat " " (List.map string_of_result rs) ^ "]"
+
+let print_results rs =
+  let ts = List.map type_of_result rs in
+  Printf.printf "%s : %s\n"
+    (string_of_results rs) (Types.string_of_value_types ts);
+  flush_all ()
+
 
 (* Configuration *)
 
@@ -281,7 +308,7 @@ let lookup_registry module_name item_name _t =
 
 (* Running *)
 
-let rec run_definition def =
+let rec run_definition def : Ast.module_ =
   match def.it with
   | Textual m -> m
   | Encoded (name, bs) ->
@@ -292,7 +319,7 @@ let rec run_definition def =
     let def' = Parse.string_to_module s in
     run_definition def'
 
-let run_action act =
+let run_action act : Values.value list =
   match act.it with
   | Invoke (x_opt, name, vs) ->
     trace ("Invoking function \"" ^ Ast.string_of_name name ^ "\"...");
@@ -313,10 +340,28 @@ let run_action act =
     | None -> Assert.error act.at "undefined export"
     )
 
-let assert_result at correct got print_expect expect =
-  if not correct then begin
-    print_string "Result: "; print_result got;
-    print_string "Expect: "; print_expect expect;
+let assert_result at got expect =
+  let open Values in
+  if
+    List.length got <> List.length expect ||
+    List.exists2 (fun v r ->
+      match r with
+      | LitResult v' -> v <> v'.it
+      | NanResult nanop ->
+        match nanop.it, v with
+        | F32 CanonicalNan, F32 z -> z <> F32.pos_nan && z <> F32.neg_nan
+        | F64 CanonicalNan, F64 z -> z <> F64.pos_nan && z <> F64.neg_nan
+        | F32 ArithmeticNan, F32 z ->
+          let pos_nan = F32.to_bits F32.pos_nan in
+          Int32.logand (F32.to_bits z) pos_nan <> pos_nan
+        | F64 ArithmeticNan, F64 z ->
+          let pos_nan = F64.to_bits F64.pos_nan in
+          Int64.logand (F64.to_bits z) pos_nan <> pos_nan
+        | _, _ -> false
+    ) got expect
+  then begin
+    print_string "Result: "; print_values got;
+    print_string "Expect: "; print_results expect;
     Assert.error at "wrong return values"
   end
 
@@ -377,35 +422,11 @@ let run_assertion ass =
     | _ -> Assert.error ass.at "expected instantiation error"
     )
 
-  | AssertReturn (act, vs) ->
-    trace ("Asserting return...");
-    let got_vs = run_action act in
-    let expect_vs = List.map (fun v -> v.it) vs in
-    assert_result ass.at (got_vs = expect_vs) got_vs print_result expect_vs
-
-  | AssertReturnCanonicalNaN act ->
-    trace ("Asserting return...");
-    let got_vs = run_action act in
-    let is_canonical_nan =
-      match got_vs with
-      | [Values.F32 got_f32] -> got_f32 = F32.pos_nan || got_f32 = F32.neg_nan
-      | [Values.F64 got_f64] -> got_f64 = F64.pos_nan || got_f64 = F64.neg_nan
-      | _ -> false
-    in assert_result ass.at is_canonical_nan got_vs print_endline "nan"
-
-  | AssertReturnArithmeticNaN act ->
+  | AssertReturn (act, rs) ->
     trace ("Asserting return...");
     let got_vs = run_action act in
-    let is_arithmetic_nan =
-      match got_vs with
-      | [Values.F32 got_f32] ->
-        let pos_nan = F32.to_bits F32.pos_nan in
-        Int32.logand (F32.to_bits got_f32) pos_nan = pos_nan
-      | [Values.F64 got_f64] ->
-        let pos_nan = F64.to_bits F64.pos_nan in
-        Int64.logand (F64.to_bits got_f64) pos_nan = pos_nan
-      | _ -> false
-    in assert_result ass.at is_arithmetic_nan got_vs print_endline "nan"
+    let expect_rs = List.map (fun r -> r.it) rs in
+    assert_result ass.at got_vs expect_rs
 
   | AssertTrap (act, re) ->
     trace ("Asserting trap...");
@@ -457,7 +478,7 @@ let rec run_command cmd =
     quote := cmd :: !quote;
     if not !Flags.dry then begin
       let vs = run_action act in
-      if vs <> [] then print_result vs
+      if vs <> [] then print_values vs
     end
 
   | Assertion ass ->
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index ca83025408..bd4e73ea3d 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -11,15 +11,22 @@ and action' =
   | Invoke of var option * Ast.name * Ast.literal list
   | Get of var option * Ast.name
 
+type nanop = nanop' Source.phrase
+and nanop' = (unit, unit, nan, nan) Values.op
+and nan = CanonicalNan | ArithmeticNan
+
+type result = result' Source.phrase
+and result' =
+  | LitResult of Ast.literal
+  | NanResult of nanop
+
 type assertion = assertion' Source.phrase
 and assertion' =
   | AssertMalformed of definition * string
   | AssertInvalid of definition * string
   | AssertUnlinkable of definition * string
   | AssertUninstantiable of definition * string
-  | AssertReturn of action * Ast.literal list
-  | AssertReturnCanonicalNaN of action
-  | AssertReturnArithmeticNaN of action
+  | AssertReturn of action * result list
   | AssertTrap of action * string
   | AssertExhaustion of action * string
 
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index f764d34cef..7b415bd636 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -417,6 +417,19 @@ let action act =
   | Get (x_opt, name) ->
     Node ("get" ^ access x_opt name, [])
 
+let nan = function
+  | CanonicalNan -> "nan:canonical"
+  | ArithmeticNan -> "nan:arithmetic"
+
+let result res =
+  match res.it with
+  | LitResult lit -> literal lit
+  | NanResult nanop ->
+    match nanop.it with
+    | Values.I32 _ | Values.I64 _ -> assert false
+    | Values.F32 n -> Node ("f32.const " ^ nan n, [])
+    | Values.F64 n -> Node ("f64.const " ^ nan n, [])
+
 let assertion mode ass =
   match ass.it with
   | AssertMalformed (def, re) ->
@@ -427,12 +440,8 @@ let assertion mode ass =
     Node ("assert_unlinkable", [definition mode None def; Atom (string re)])
   | AssertUninstantiable (def, re) ->
     Node ("assert_trap", [definition mode None def; Atom (string re)])
-  | AssertReturn (act, lits) ->
-    Node ("assert_return", action act :: List.map literal lits)
-  | AssertReturnCanonicalNaN act ->
-    Node ("assert_return_canonical_nan", [action act])
-  | AssertReturnArithmeticNaN act ->
-    Node ("assert_return_arithmetic_nan", [action act])
+  | AssertReturn (act, results) ->
+    Node ("assert_return", action act :: List.map result results)
   | AssertTrap (act, re) ->
     Node ("assert_trap", [action act; Atom (string re)])
   | AssertExhaustion (act, re) ->
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index dab48e0453..3483149df6 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -344,10 +344,10 @@ rule token = parse
   | "assert_invalid" { ASSERT_INVALID }
   | "assert_unlinkable" { ASSERT_UNLINKABLE }
   | "assert_return" { ASSERT_RETURN }
-  | "assert_return_canonical_nan" { ASSERT_RETURN_CANONICAL_NAN }
-  | "assert_return_arithmetic_nan" { ASSERT_RETURN_ARITHMETIC_NAN }
   | "assert_trap" { ASSERT_TRAP }
   | "assert_exhaustion" { ASSERT_EXHAUSTION }
+  | "nan:canonical" { NAN Script.CanonicalNan }
+  | "nan:arithmetic" { NAN Script.ArithmeticNan }
   | "input" { INPUT }
   | "output" { OUTPUT }
 
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 670afd6bae..a556cf7c6e 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -39,6 +39,14 @@ let ati i =
 let literal f s =
   try f s with Failure _ -> error s.at "constant out of range"
 
+let nanop f nan =
+  let open Source in
+  let open Values in
+  match snd (f ("0" @@ no_region)) with
+  | F32 _ -> F32 nan.it @@ nan.at
+  | F64 _ -> F64 nan.it @@ nan.at
+  | I32 _ | I64 _ -> error nan.at "NaN pattern with non-float type"
+
 let nat s at =
   try
     let n = int_of_string s in
@@ -157,7 +165,8 @@ let inline_type_explicit (c : context) x ft at =
 %token MODULE BIN QUOTE
 %token SCRIPT REGISTER INVOKE GET
 %token ASSERT_MALFORMED ASSERT_INVALID ASSERT_SOFT_INVALID ASSERT_UNLINKABLE
-%token ASSERT_RETURN ASSERT_RETURN_CANONICAL_NAN ASSERT_RETURN_ARITHMETIC_NAN ASSERT_TRAP ASSERT_EXHAUSTION
+%token ASSERT_RETURN ASSERT_TRAP ASSERT_EXHAUSTION
+%token NAN
 %token INPUT OUTPUT
 %token EOF
 
@@ -178,6 +187,8 @@ let inline_type_explicit (c : context) x ft at =
 %token<string> OFFSET_EQ_NAT
 %token<string> ALIGN_EQ_NAT
 
+%token<Script.nan> NAN
+
 %nonassoc LOW
 %nonassoc VAR
 
@@ -795,9 +806,7 @@ assertion :
     { AssertUnlinkable (snd $3, $4) @@ at () }
   | LPAR ASSERT_TRAP script_module STRING RPAR
     { AssertUninstantiable (snd $3, $4) @@ at () }
-  | LPAR ASSERT_RETURN action const_list RPAR { AssertReturn ($3, $4) @@ at () }
-  | LPAR ASSERT_RETURN_CANONICAL_NAN action RPAR { AssertReturnCanonicalNaN $3 @@ at () }
-  | LPAR ASSERT_RETURN_ARITHMETIC_NAN action RPAR { AssertReturnArithmeticNaN $3 @@ at () }
+  | LPAR ASSERT_RETURN action result_list RPAR { AssertReturn ($3, $4) @@ at () }
   | LPAR ASSERT_TRAP action STRING RPAR { AssertTrap ($3, $4) @@ at () }
   | LPAR ASSERT_EXHAUSTION action STRING RPAR { AssertExhaustion ($3, $4) @@ at () }
 
@@ -825,6 +834,14 @@ const_list :
   | /* empty */ { [] }
   | const const_list { $1 :: $2 }
 
+result :
+  | const { LitResult $1 @@ at () }
+  | LPAR CONST NAN RPAR { NanResult (nanop $2 ($3 @@ ati 3)) @@ at () }
+
+result_list :
+  | /* empty */ { [] }
+  | result result_list { $1 :: $2 }
+
 script :
   | cmd_list EOF { $1 }
   | inline_module1 EOF { [Module (None, $1) @@ at ()] }  /* Sugar */
diff --git a/test/core/conversions.wast b/test/core/conversions.wast
index c0ae54a53b..308296d2e0 100644
--- a/test/core/conversions.wast
+++ b/test/core/conversions.wast
@@ -354,10 +354,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 inf)) (f64.const inf))
 (assert_return (invoke "f64.promote_f32" (f32.const -inf)) (f64.const -inf))
-(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 "f64.promote_f32" (f32.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.promote_f32" (f32.const nan:0x200000)) (f64.const nan:arithmetic))
+(assert_return (invoke "f64.promote_f32" (f32.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.promote_f32" (f32.const -nan:0x200000)) (f64.const nan:arithmetic))
 
 (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))
@@ -401,10 +401,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_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 nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.demote_f64" (f64.const nan:0x4000000000000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.demote_f64" (f64.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.demote_f64" (f64.const -nan:0x4000000000000)) (f32.const nan:arithmetic))
 (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 4f0881c252..36d81a05bf 100644
--- a/test/core/f32.wast
+++ b/test/core/f32.wast
@@ -48,14 +48,14 @@
 (assert_return (invoke "add" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf))
-(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 -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -88,14 +88,14 @@
 (assert_return (invoke "add" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
-(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-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -128,14 +128,14 @@
 (assert_return (invoke "add" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
-(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-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -168,14 +168,14 @@
 (assert_return (invoke "add" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
-(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-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -208,14 +208,14 @@
 (assert_return (invoke "add" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
-(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 -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -248,14 +248,14 @@
 (assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
-(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.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -288,14 +288,14 @@
 (assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
-(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 -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "add" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
@@ -325,97 +325,97 @@
 (assert_return (invoke "add" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
 (assert_return (invoke "add" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
 (assert_return (invoke "add" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
-(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const inf)))
-(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const -inf)))
+(assert_return (invoke "add" (f32.const -inf) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const inf) (f32.const -inf)) (f32.const nan:canonical))
 (assert_return (invoke "add" (f32.const inf) (f32.const inf)) (f32.const inf))
-(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const -inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const -inf) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const inf)))
-(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -inf)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const inf)))
-(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 "add" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -448,14 +448,14 @@
 (assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -inf)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const inf)) (f32.const -inf))
-(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 -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -488,14 +488,14 @@
 (assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -inf)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const inf)) (f32.const -inf))
-(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-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -528,14 +528,14 @@
 (assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -inf)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const inf)) (f32.const -inf))
-(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-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -568,14 +568,14 @@
 (assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -inf)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const inf)) (f32.const -inf))
-(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-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -608,14 +608,14 @@
 (assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -inf)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const inf)) (f32.const -inf))
-(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 -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -648,14 +648,14 @@
 (assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
-(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.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -688,14 +688,14 @@
 (assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
-(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 -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "sub" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
@@ -724,98 +724,98 @@
 (assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
-(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const -inf)))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -inf)) (f32.const nan:canonical))
 (assert_return (invoke "sub" (f32.const -inf) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "sub" (f32.const inf) (f32.const -inf)) (f32.const inf))
-(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const inf)))
-(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const -inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const -inf) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const inf)))
-(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -inf)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const inf)))
-(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 "sub" (f32.const inf) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -844,18 +844,18 @@
 (assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const inf)))
-(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const inf)))
-(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 -0x0p+0) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -888,14 +888,14 @@
 (assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
-(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-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -928,14 +928,14 @@
 (assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
-(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-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -968,14 +968,14 @@
 (assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
-(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-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -1008,14 +1008,14 @@
 (assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
-(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 -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -1048,14 +1048,14 @@
 (assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
-(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.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -1088,18 +1088,18 @@
 (assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
-(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 -inf) (f32.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const 0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const 0x0p+0)))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x0p+0)) (f32.const nan:canonical))
 (assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf))
 (assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf))
@@ -1128,98 +1128,98 @@
 (assert_return (invoke "mul" (f32.const -inf) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const inf) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "mul" (f32.const inf) (f32.const inf)) (f32.const inf))
-(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const -inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const -inf) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const inf)))
-(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -inf)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const inf)))
-(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)))
-(assert_return_canonical_nan (invoke "div" (f32.const 0x0p+0) (f32.const 0x0p+0)))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const nan:canonical))
 (assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const 0x0p+0))
 (assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
@@ -1248,14 +1248,14 @@
 (assert_return (invoke "div" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const inf)) (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 -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -inf))
@@ -1288,14 +1288,14 @@
 (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const inf)) (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-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -inf))
@@ -1328,14 +1328,14 @@
 (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const inf)) (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-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -inf))
@@ -1368,14 +1368,14 @@
 (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const inf)) (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-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -inf))
@@ -1408,14 +1408,14 @@
 (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const inf)) (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 -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -inf))
@@ -1448,14 +1448,14 @@
 (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const inf)) (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.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -inf))
@@ -1488,14 +1488,14 @@
 (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const inf)) (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 -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "div" (f32.const -inf) (f32.const -0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf))
@@ -1524,98 +1524,98 @@
 (assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
 (assert_return (invoke "div" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
-(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const inf)))
-(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const inf)))
-(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const -inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const -inf) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const inf)))
-(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -inf)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const inf)))
-(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 "div" (f32.const -inf) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -inf) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const inf) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const inf) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -1648,14 +1648,14 @@
 (assert_return (invoke "min" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0))
 (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const inf)) (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 -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
 (assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149))
 (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1688,14 +1688,14 @@
 (assert_return (invoke "min" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x1p-149))
 (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const inf)) (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-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
 (assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126))
 (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1728,14 +1728,14 @@
 (assert_return (invoke "min" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x1p-126))
 (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const inf)) (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-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
 (assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1))
 (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1768,14 +1768,14 @@
 (assert_return (invoke "min" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x1p-1))
 (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const inf)) (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-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
 (assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0))
 (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1808,14 +1808,14 @@
 (assert_return (invoke "min" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x1p+0))
 (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const inf)) (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 -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1848,14 +1848,14 @@
 (assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const inf)) (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.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1888,14 +1888,14 @@
 (assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const inf)) (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 -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "min" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const inf) (f32.const -0x0p+0)) (f32.const -0x0p+0))
@@ -1928,94 +1928,94 @@
 (assert_return (invoke "min" (f32.const -inf) (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const inf) (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "min" (f32.const inf) (f32.const inf)) (f32.const inf))
-(assert_return_canonical_nan (invoke "min" (f32.const -inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const -inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "min" (f32.const -inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const -inf) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "min" (f32.const inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "min" (f32.const inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const inf) (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_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_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_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_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_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_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_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 -inf)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const inf)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -inf)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const inf)))
-(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_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 "min" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -2048,14 +2048,14 @@
 (assert_return (invoke "max" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -inf)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf))
-(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 -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149))
@@ -2088,14 +2088,14 @@
 (assert_return (invoke "max" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -inf)) (f32.const 0x1p-149))
 (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
-(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-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126))
@@ -2128,14 +2128,14 @@
 (assert_return (invoke "max" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -inf)) (f32.const 0x1p-126))
 (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
-(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-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1))
@@ -2168,14 +2168,14 @@
 (assert_return (invoke "max" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -inf)) (f32.const 0x1p-1))
 (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
-(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-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0))
@@ -2208,14 +2208,14 @@
 (assert_return (invoke "max" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -inf)) (f32.const 0x1p+0))
 (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
-(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 -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2))
@@ -2248,14 +2248,14 @@
 (assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x1.921fb6p+2))
 (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
-(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.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127))
@@ -2288,14 +2288,14 @@
 (assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
-(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 -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "max" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "max" (f32.const -inf) (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
@@ -2328,114 +2328,114 @@
 (assert_return (invoke "max" (f32.const -inf) (f32.const inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const inf) (f32.const -inf)) (f32.const inf))
 (assert_return (invoke "max" (f32.const inf) (f32.const inf)) (f32.const inf))
-(assert_return_canonical_nan (invoke "max" (f32.const -inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const -inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "max" (f32.const -inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const -inf) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "max" (f32.const inf) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const inf) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "max" (f32.const inf) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const inf)))
-(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -inf)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -inf)))
-(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const inf)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const inf)))
-(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_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const nan:0x200000)))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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)))
+(assert_return (invoke "sqrt" (f32.const -0x1p-149)) (f32.const nan:canonical))
 (assert_return (invoke "sqrt" (f32.const 0x1p-149)) (f32.const 0x1.6a09e6p-75))
-(assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1p-126)))
+(assert_return (invoke "sqrt" (f32.const -0x1p-126)) (f32.const nan:canonical))
 (assert_return (invoke "sqrt" (f32.const 0x1p-126)) (f32.const 0x1p-63))
-(assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1p-1)))
+(assert_return (invoke "sqrt" (f32.const -0x1p-1)) (f32.const nan:canonical))
 (assert_return (invoke "sqrt" (f32.const 0x1p-1)) (f32.const 0x1.6a09e6p-1))
-(assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1p+0)))
+(assert_return (invoke "sqrt" (f32.const -0x1p+0)) (f32.const nan:canonical))
 (assert_return (invoke "sqrt" (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1.921fb6p+2)))
+(assert_return (invoke "sqrt" (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
 (assert_return (invoke "sqrt" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.40d932p+1))
-(assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1.fffffep+127)))
+(assert_return (invoke "sqrt" (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
 (assert_return (invoke "sqrt" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+63))
-(assert_return_canonical_nan (invoke "sqrt" (f32.const -inf)))
+(assert_return (invoke "sqrt" (f32.const -inf)) (f32.const nan:canonical))
 (assert_return (invoke "sqrt" (f32.const inf)) (f32.const inf))
-(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 "sqrt" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sqrt" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -2452,10 +2452,10 @@
 (assert_return (invoke "floor" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "floor" (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "floor" (f32.const inf)) (f32.const inf))
-(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 "floor" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "floor" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "floor" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "floor" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -2472,10 +2472,10 @@
 (assert_return (invoke "ceil" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "ceil" (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "ceil" (f32.const inf)) (f32.const inf))
-(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 "ceil" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "ceil" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "ceil" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "ceil" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -2492,10 +2492,10 @@
 (assert_return (invoke "trunc" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "trunc" (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "trunc" (f32.const inf)) (f32.const inf))
-(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 "trunc" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "trunc" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "trunc" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "trunc" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (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))
@@ -2512,10 +2512,10 @@
 (assert_return (invoke "nearest" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "nearest" (f32.const -inf)) (f32.const -inf))
 (assert_return (invoke "nearest" (f32.const inf)) (f32.const inf))
-(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_arithmetic_nan (invoke "nearest" (f32.const nan:0x200000)))
+(assert_return (invoke "nearest" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "nearest" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "nearest" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "nearest" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 
 
 ;; Type check
diff --git a/test/core/f64.wast b/test/core/f64.wast
index 85c8834b75..70bb477c77 100644
--- a/test/core/f64.wast
+++ b/test/core/f64.wast
@@ -48,14 +48,14 @@
 (assert_return (invoke "add" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf))
-(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 -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -88,14 +88,14 @@
 (assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
-(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 -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -128,14 +128,14 @@
 (assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
-(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-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -168,14 +168,14 @@
 (assert_return (invoke "add" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
-(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-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -208,14 +208,14 @@
 (assert_return (invoke "add" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
-(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 -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -248,14 +248,14 @@
 (assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
-(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.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -288,14 +288,14 @@
 (assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
-(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 -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "add" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
@@ -325,97 +325,97 @@
 (assert_return (invoke "add" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
 (assert_return (invoke "add" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
 (assert_return (invoke "add" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
-(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const inf)))
-(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const -inf)))
+(assert_return (invoke "add" (f64.const -inf) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const inf) (f64.const -inf)) (f64.const nan:canonical))
 (assert_return (invoke "add" (f64.const inf) (f64.const inf)) (f64.const inf))
-(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const -inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const -inf) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const inf)))
-(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -inf)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const inf)))
-(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 "add" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -448,14 +448,14 @@
 (assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -inf)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const inf)) (f64.const -inf))
-(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 -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -488,14 +488,14 @@
 (assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
-(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 -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -528,14 +528,14 @@
 (assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const inf)) (f64.const -inf))
-(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-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -568,14 +568,14 @@
 (assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -inf)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const inf)) (f64.const -inf))
-(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-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -608,14 +608,14 @@
 (assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -inf)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const inf)) (f64.const -inf))
-(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 -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -648,14 +648,14 @@
 (assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
-(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.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -688,14 +688,14 @@
 (assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
-(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 -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
@@ -724,98 +724,98 @@
 (assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
-(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const -inf)))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -inf)) (f64.const nan:canonical))
 (assert_return (invoke "sub" (f64.const -inf) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "sub" (f64.const inf) (f64.const -inf)) (f64.const inf))
-(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const inf)))
-(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const -inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const -inf) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const inf)))
-(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -inf)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const inf)))
-(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 "sub" (f64.const inf) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -844,18 +844,18 @@
 (assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const inf)))
-(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const inf)))
-(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 -0x0p+0) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -888,14 +888,14 @@
 (assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
-(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 -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -928,14 +928,14 @@
 (assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
-(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-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -968,14 +968,14 @@
 (assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
-(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-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -1008,14 +1008,14 @@
 (assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
-(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 -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -1048,14 +1048,14 @@
 (assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
-(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.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -1088,18 +1088,18 @@
 (assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
-(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 -inf) (f64.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const 0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const 0x0p+0)))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x0p+0)) (f64.const nan:canonical))
 (assert_return (invoke "mul" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
 (assert_return (invoke "mul" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
@@ -1128,98 +1128,98 @@
 (assert_return (invoke "mul" (f64.const -inf) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const inf) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "mul" (f64.const inf) (f64.const inf)) (f64.const inf))
-(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const -inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const -inf) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const inf)))
-(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -inf)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const inf)))
-(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)))
-(assert_return_canonical_nan (invoke "div" (f64.const 0x0p+0) (f64.const 0x0p+0)))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const nan:canonical))
 (assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
 (assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
@@ -1248,14 +1248,14 @@
 (assert_return (invoke "div" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const inf)) (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 -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -inf))
@@ -1288,14 +1288,14 @@
 (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (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 -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -inf))
@@ -1328,14 +1328,14 @@
 (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const inf)) (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-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -inf))
@@ -1368,14 +1368,14 @@
 (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const inf)) (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-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -inf))
@@ -1408,14 +1408,14 @@
 (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const inf)) (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 -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -inf))
@@ -1448,14 +1448,14 @@
 (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (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.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -inf))
@@ -1488,14 +1488,14 @@
 (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (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 -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "div" (f64.const -inf) (f64.const -0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf))
@@ -1524,98 +1524,98 @@
 (assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
 (assert_return (invoke "div" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
-(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const inf)))
-(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const inf)))
-(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const -inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const -inf) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const inf) (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 -inf)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const inf)))
-(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -inf)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const inf)))
-(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 "div" (f64.const -inf) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -inf) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const inf) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const inf) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -1648,14 +1648,14 @@
 (assert_return (invoke "min" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0))
 (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const inf)) (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 -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1688,14 +1688,14 @@
 (assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (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 -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
 (assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022))
 (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1728,14 +1728,14 @@
 (assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x1p-1022))
 (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const inf)) (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-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
 (assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1))
 (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1768,14 +1768,14 @@
 (assert_return (invoke "min" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x1p-1))
 (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const inf)) (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-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
 (assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0))
 (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1808,14 +1808,14 @@
 (assert_return (invoke "min" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x1p+0))
 (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const inf)) (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 -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1848,14 +1848,14 @@
 (assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (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.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1888,14 +1888,14 @@
 (assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (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 -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "min" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const inf) (f64.const -0x0p+0)) (f64.const -0x0p+0))
@@ -1928,94 +1928,94 @@
 (assert_return (invoke "min" (f64.const -inf) (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const inf) (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "min" (f64.const inf) (f64.const inf)) (f64.const inf))
-(assert_return_canonical_nan (invoke "min" (f64.const -inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const -inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "min" (f64.const -inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const -inf) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "min" (f64.const inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "min" (f64.const inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const inf) (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_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_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_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_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_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_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_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 -inf)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const inf)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -inf)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const inf)))
-(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_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 "min" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -2048,14 +2048,14 @@
 (assert_return (invoke "max" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -inf)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf))
-(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 -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022))
@@ -2088,14 +2088,14 @@
 (assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0.0000000000001p-1022))
 (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
-(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 -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022))
@@ -2128,14 +2128,14 @@
 (assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const 0x1p-1022))
 (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
-(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-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1))
@@ -2168,14 +2168,14 @@
 (assert_return (invoke "max" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -inf)) (f64.const 0x1p-1))
 (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
-(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-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0))
@@ -2208,14 +2208,14 @@
 (assert_return (invoke "max" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -inf)) (f64.const 0x1p+0))
 (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
-(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 -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
@@ -2248,14 +2248,14 @@
 (assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
-(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.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
@@ -2288,14 +2288,14 @@
 (assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
-(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 -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (assert_return (invoke "max" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "max" (f64.const -inf) (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
@@ -2328,114 +2328,114 @@
 (assert_return (invoke "max" (f64.const -inf) (f64.const inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const inf) (f64.const -inf)) (f64.const inf))
 (assert_return (invoke "max" (f64.const inf) (f64.const inf)) (f64.const inf))
-(assert_return_canonical_nan (invoke "max" (f64.const -inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const -inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "max" (f64.const -inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const -inf) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "max" (f64.const inf) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const inf) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "max" (f64.const inf) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const inf) (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_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_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_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_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_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_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_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 -inf)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const inf)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -inf)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -inf)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const inf)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const inf)))
-(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_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 (invoke "max" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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)))
+(assert_return (invoke "sqrt" (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
 (assert_return (invoke "sqrt" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-537))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1p-1022)))
+(assert_return (invoke "sqrt" (f64.const -0x1p-1022)) (f64.const nan:canonical))
 (assert_return (invoke "sqrt" (f64.const 0x1p-1022)) (f64.const 0x1p-511))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1p-1)))
+(assert_return (invoke "sqrt" (f64.const -0x1p-1)) (f64.const nan:canonical))
 (assert_return (invoke "sqrt" (f64.const 0x1p-1)) (f64.const 0x1.6a09e667f3bcdp-1))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1p+0)))
+(assert_return (invoke "sqrt" (f64.const -0x1p+0)) (f64.const nan:canonical))
 (assert_return (invoke "sqrt" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1.921fb54442d18p+2)))
+(assert_return (invoke "sqrt" (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
 (assert_return (invoke "sqrt" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.40d931ff62705p+1))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return (invoke "sqrt" (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
 (assert_return (invoke "sqrt" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+511))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -inf)))
+(assert_return (invoke "sqrt" (f64.const -inf)) (f64.const nan:canonical))
 (assert_return (invoke "sqrt" (f64.const inf)) (f64.const inf))
-(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 "sqrt" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sqrt" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -2452,10 +2452,10 @@
 (assert_return (invoke "floor" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "floor" (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "floor" (f64.const inf)) (f64.const inf))
-(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 "floor" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "floor" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "floor" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "floor" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -2472,10 +2472,10 @@
 (assert_return (invoke "ceil" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "ceil" (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "ceil" (f64.const inf)) (f64.const inf))
-(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 "ceil" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "ceil" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "ceil" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "ceil" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -2492,10 +2492,10 @@
 (assert_return (invoke "trunc" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "trunc" (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "trunc" (f64.const inf)) (f64.const inf))
-(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 "trunc" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "trunc" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "trunc" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "trunc" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 (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))
@@ -2512,10 +2512,10 @@
 (assert_return (invoke "nearest" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "nearest" (f64.const -inf)) (f64.const -inf))
 (assert_return (invoke "nearest" (f64.const inf)) (f64.const inf))
-(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_arithmetic_nan (invoke "nearest" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "nearest" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "nearest" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "nearest" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "nearest" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 
 ;; Type check
diff --git a/test/core/float_exprs.wast b/test/core/float_exprs.wast
index e6583634f1..1f88299212 100644
--- a/test/core/float_exprs.wast
+++ b/test/core/float_exprs.wast
@@ -46,8 +46,8 @@
 
 (assert_return (invoke "f32.no_fold_add_zero" (f32.const -0.0)) (f32.const 0.0))
 (assert_return (invoke "f64.no_fold_add_zero" (f64.const -0.0)) (f64.const 0.0))
-(assert_return_arithmetic_nan (invoke "f32.no_fold_add_zero" (f32.const nan:0x200000)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_add_zero" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_add_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_add_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that 0.0 - x is not folded to -x.
 
@@ -60,8 +60,8 @@
 
 (assert_return (invoke "f32.no_fold_zero_sub" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f64.no_fold_zero_sub" (f64.const 0.0)) (f64.const 0.0))
-(assert_return_arithmetic_nan (invoke "f32.no_fold_zero_sub" (f32.const nan:0x200000)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_zero_sub" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_zero_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_zero_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that x - 0.0 is not folded to x.
 
@@ -72,8 +72,8 @@
     (f64.sub (local.get $x) (f64.const 0.0)))
 )
 
-(assert_return_arithmetic_nan (invoke "f32.no_fold_sub_zero" (f32.const nan:0x200000)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_sub_zero" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_sub_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_sub_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that x*0.0 is not folded to 0.0.
 
@@ -87,11 +87,11 @@
 (assert_return (invoke "f32.no_fold_mul_zero" (f32.const -0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_mul_zero" (f32.const -1.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_mul_zero" (f32.const -2.0)) (f32.const -0.0))
-(assert_return_arithmetic_nan (invoke "f32.no_fold_mul_zero" (f32.const nan:0x200000)))
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "f64.no_fold_mul_zero" (f64.const -0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_mul_zero" (f64.const -1.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_mul_zero" (f64.const -2.0)) (f64.const -0.0))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_mul_zero" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that x*1.0 is not folded to x.
 ;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
@@ -103,8 +103,8 @@
     (f64.mul (local.get $x) (f64.const 1.0)))
 )
 
-(assert_return_arithmetic_nan (invoke "f32.no_fold_mul_one" (f32.const nan:0x200000)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_mul_one" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_mul_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_mul_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that 0.0/x is not folded to 0.0.
 
@@ -115,14 +115,14 @@
     (f64.div (f64.const 0.0) (local.get $x)))
 )
 
-(assert_return_canonical_nan (invoke "f32.no_fold_zero_div" (f32.const 0.0)))
-(assert_return_canonical_nan (invoke "f32.no_fold_zero_div" (f32.const -0.0)))
-(assert_return_canonical_nan (invoke "f32.no_fold_zero_div" (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "f32.no_fold_zero_div" (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "f64.no_fold_zero_div" (f64.const 0.0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_zero_div" (f64.const -0.0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_zero_div" (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_zero_div" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const 0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const -0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const 0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const -0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that x/1.0 is not folded to x.
 
@@ -133,8 +133,8 @@
     (f64.div (local.get $x) (f64.const 1.0)))
 )
 
-(assert_return_arithmetic_nan (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_div_one" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_div_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that x/-1.0 is not folded to -x.
 
@@ -145,8 +145,8 @@
     (f64.div (local.get $x) (f64.const -1.0)))
 )
 
-(assert_return_arithmetic_nan (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_div_neg1" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_div_neg1" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that -0.0 - x is not folded to -x.
 
@@ -157,8 +157,8 @@
     (f64.sub (f64.const -0.0) (local.get $x)))
 )
 
-(assert_return_arithmetic_nan (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_neg0_sub" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_neg0_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that -1.0 * x is not folded to -x.
 
@@ -169,8 +169,8 @@
     (f64.mul (f64.const -1.0) (local.get $x)))
 )
 
-(assert_return_arithmetic_nan (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_neg1_mul" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_neg1_mul" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that x == x is not folded to true.
 
@@ -205,10 +205,10 @@
     (f64.sub (local.get $x) (local.get $x)))
 )
 
-(assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const inf)))
-(assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const nan)))
-(assert_return_canonical_nan (invoke "f64.no_fold_sub_self" (f64.const inf)))
-(assert_return_canonical_nan (invoke "f64.no_fold_sub_self" (f64.const nan)))
+(assert_return (invoke "f32.no_fold_sub_self" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_sub_self" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_sub_self" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_sub_self" (f64.const nan)) (f64.const nan:canonical))
 
 ;; Test that x / x is not folded to 1.0.
 
@@ -219,14 +219,14 @@
     (f64.div (local.get $x) (local.get $x)))
 )
 
-(assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const inf)))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const nan)))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const 0.0)))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const -0.0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const inf)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const nan)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const 0.0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const -0.0)))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const 0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const -0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const 0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const -0.0)) (f64.const nan:canonical))
 
 ;; Test that x/3 is not folded to x*(1/3).
 
@@ -381,18 +381,18 @@
 (assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -inf))
 (assert_return (invoke "f32.no_fold_div_0" (f32.const inf)) (f32.const inf))
 (assert_return (invoke "f32.no_fold_div_0" (f32.const -inf)) (f32.const -inf))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const 0)))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const -0)))
-(assert_return_arithmetic_nan (invoke "f32.no_fold_div_0" (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const nan)))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const 0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const nan)) (f32.const nan:canonical))
 (assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const inf))
 (assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -inf))
 (assert_return (invoke "f64.no_fold_div_0" (f64.const inf)) (f64.const inf))
 (assert_return (invoke "f64.no_fold_div_0" (f64.const -inf)) (f64.const -inf))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const 0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const -0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_div_0" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const 0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that x/-0 is not folded away.
 
@@ -407,18 +407,18 @@
 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const inf))
 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const -inf)) (f32.const inf))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const 0)))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const -0)))
-(assert_return_arithmetic_nan (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const nan)))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan)) (f32.const nan:canonical))
 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -inf))
 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const inf))
 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const -inf)) (f64.const inf))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const 0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const -0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "f64.no_fold_div_neg0" (f64.const nan:0x4000000000000)))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
 
 ;; Test that sqrt(x*x+y*y) is not folded to hypot.
 
@@ -635,7 +635,7 @@
     (f32.demote_f64 (f64.promote_f32 (local.get $x))))
 )
 
-(assert_return_arithmetic_nan (invoke "no_fold_promote_demote" (f32.const nan:0x200000)))
+(assert_return (invoke "no_fold_promote_demote" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
 (assert_return (invoke "no_fold_promote_demote" (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "no_fold_promote_demote" (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-149)) (f32.const 0x1p-149))
@@ -1653,13 +1653,13 @@
 
 (assert_return (invoke "f32.no_fold_add_neg" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_add_neg" (f32.const -0.0)) (f32.const 0.0))
-(assert_return_canonical_nan (invoke "f32.no_fold_add_neg" (f32.const inf)))
-(assert_return_canonical_nan (invoke "f32.no_fold_add_neg" (f32.const -inf)))
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const -inf)) (f32.const nan:canonical))
 
 (assert_return (invoke "f64.no_fold_add_neg" (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_add_neg" (f64.const -0.0)) (f64.const 0.0))
-(assert_return_canonical_nan (invoke "f64.no_fold_add_neg" (f64.const inf)))
-(assert_return_canonical_nan (invoke "f64.no_fold_add_neg" (f64.const -inf)))
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const -inf)) (f64.const nan:canonical))
 
 ;; Test that x+x+x+x+x+x is not folded to x * 6.
 
@@ -1790,13 +1790,13 @@
     (f64.mul (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
 )
 
-(assert_return_canonical_nan (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.dddda8p-125) (f32.const -0x1.25d22ap-83)))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.dddda8p-125) (f32.const -0x1.25d22ap-83)) (f32.const nan:canonical))
 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.418d14p-92) (f32.const 0x1.c6535cp-32)) (f32.const 0x1.7e373ap-62))
 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.4de7ep-88) (f32.const 0x1.84ff18p+6)) (f32.const 0x1.686668p-41))
 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.78091ep+101) (f32.const 0x1.81feb8p-9)) (f32.const 0x1.7cfb98p+46))
 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.583ap-56) (f32.const 0x1.14ba2ap-9)) (f32.const 0x1.b47a8ep-33))
 
-(assert_return_canonical_nan (invoke "f64.no_fold_mul_sqrts" (f64.const -0x1.d1144cc28cdbep-635) (f64.const -0x1.bf9bc373d3b6ap-8)))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const -0x1.d1144cc28cdbep-635) (f64.const -0x1.bf9bc373d3b6ap-8)) (f64.const nan:canonical))
 (assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.5a7eb976bebc9p-643) (f64.const 0x1.f30cb8865a4cap-404)) (f64.const 0x1.260a1032d6e76p-523))
 (assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.711a0c1707935p-89) (f64.const 0x1.6fb5de51a20d3p-913)) (f64.const 0x1.7067ca28e31ecp-501))
 (assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.fb0bbea33b076p-363) (f64.const 0x1.d963b34894158p-573)) (f64.const 0x1.e9edc1fa624afp-468))
@@ -1812,13 +1812,13 @@
     (f64.div (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
 )
 
-(assert_return_canonical_nan (invoke "f32.no_fold_div_sqrts" (f32.const -0x1.bea9bap+25) (f32.const -0x1.db776ep-58)))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const -0x1.bea9bap+25) (f32.const -0x1.db776ep-58)) (f32.const nan:canonical))
 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b983b6p+32) (f32.const 0x1.901f1ep+27)) (f32.const 0x1.7c4df6p+2))
 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.d45e72p-120) (f32.const 0x1.ab49ccp+15)) (f32.const 0x1.7b0b04p-68))
 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b2e444p+59) (f32.const 0x1.5b8b16p-30)) (f32.const 0x1.94fca8p+44))
 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.835aa6p-112) (f32.const 0x1.d17128p-103)) (f32.const 0x1.4a468p-5))
 
-(assert_return_canonical_nan (invoke "f64.no_fold_div_sqrts" (f64.const -0x1.509fc16411167p-711) (f64.const -0x1.9c4255f5d6517p-187)))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const -0x1.509fc16411167p-711) (f64.const -0x1.9c4255f5d6517p-187)) (f64.const nan:canonical))
 (assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.b6897bddac76p-587) (f64.const 0x1.104578b4c91f3p+541)) (f64.const 0x1.44e4f21f26cc9p-564))
 (assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.ac83451b08989p+523) (f64.const 0x1.8da575c6d12b8p-109)) (f64.const 0x1.09c003991ce17p+316))
 (assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.bab7836456417p-810) (f64.const 0x1.1ff60d03ba607p+291)) (f64.const 0x1.c0e6c833bf657p-551))
diff --git a/test/core/float_misc.wast b/test/core/float_misc.wast
index 1aad1a35a3..3d83281d77 100644
--- a/test/core/float_misc.wast
+++ b/test/core/float_misc.wast
@@ -569,7 +569,7 @@
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.c201b94757145p-492)) (f64.const 0x1.5369ee6bf2967p-246))
 
 ;; Computations that round differently when computed via f32.
-(assert_return_canonical_nan (invoke "f64.sqrt" (f64.const -0x1.360e8d0032adp-963)))
+(assert_return (invoke "f64.sqrt" (f64.const -0x1.360e8d0032adp-963)) (f64.const nan:canonical))
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.d9a6f5eef0503p+103)) (f64.const 0x1.ec73f56c166f6p+51))
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.aa051a5c4ec27p-760)) (f64.const 0x1.4a3e771ff5149p-380))
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.e5522a741babep-276)) (f64.const 0x1.607ae2b6feb7dp-138))